diff --git a/oscar64/ByteCodeGenerator.cpp b/oscar64/ByteCodeGenerator.cpp
index 511f1dea..c814ca68 100644
--- a/oscar64/ByteCodeGenerator.cpp
+++ b/oscar64/ByteCodeGenerator.cpp
@@ -577,132 +577,132 @@ void ByteCodeBasicBlock::IntConstToAddr(__int64 val)
 	mIns.Push(ins);
 }
 
-void ByteCodeBasicBlock::LoadConstant(InterCodeProcedure* proc, const InterInstruction& ins)
+void ByteCodeBasicBlock::LoadConstant(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	if (ins.mTType == IT_FLOAT)
+	if (ins->mTType == IT_FLOAT)
 	{
 		union { float f; int v; } cc;
-		cc.f = ins.mFloatValue;
+		cc.f = ins->mFloatValue;
 		ByteCodeInstruction	bins(BC_CONST_32);
-		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 		bins.mValue = cc.v;
 		mIns.Push(bins);
 	}
-	else if (ins.mTType == IT_POINTER)
+	else if (ins->mTType == IT_POINTER)
 	{
-		if (ins.mMemory == IM_GLOBAL)
+		if (ins->mMemory == IM_GLOBAL)
 		{
 			ByteCodeInstruction	bins(BC_LEA_ABS);
-			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-			bins.mVIndex = ins.mVarIndex;
-			bins.mValue = ins.mIntValue;
+			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+			bins.mVIndex = ins->mVarIndex;
+			bins.mValue = ins->mIntValue;
 			bins.mRelocate = true;
 			bins.mFunction = false;
 			mIns.Push(bins);
 		}
-		else if (ins.mMemory == IM_ABSOLUTE)
+		else if (ins->mMemory == IM_ABSOLUTE)
 		{
 			ByteCodeInstruction	bins(BC_LEA_ABS);
-			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-			bins.mValue = ins.mIntValue;
+			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+			bins.mValue = ins->mIntValue;
 			mIns.Push(bins);
 		}
-		else if (ins.mMemory == IM_LOCAL)
+		else if (ins->mMemory == IM_LOCAL)
 		{
 			ByteCodeInstruction	bins(BC_LEA_LOCAL);
-			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-			bins.mValue = ins.mIntValue + proc->mLocalVars[ins.mVarIndex].mOffset;
+			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+			bins.mValue = ins->mIntValue + proc->mLocalVars[ins->mVarIndex].mOffset;
 			mIns.Push(bins);
 		}
-		else if (ins.mMemory == IM_PARAM)
+		else if (ins->mMemory == IM_PARAM)
 		{
 			ByteCodeInstruction	bins(BC_LEA_LOCAL);
-			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-			bins.mValue = ins.mIntValue + ins.mVarIndex + proc->mLocalSize + 2;
+			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+			bins.mValue = ins->mIntValue + ins->mVarIndex + proc->mLocalSize + 2;
 			mIns.Push(bins);
 		}
-		else if (ins.mMemory == IM_PROCEDURE)
+		else if (ins->mMemory == IM_PROCEDURE)
 		{
 			ByteCodeInstruction	bins(BC_CONST_16);
-			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-			bins.mVIndex = ins.mVarIndex;
+			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+			bins.mVIndex = ins->mVarIndex;
 			bins.mValue = 0;
 			bins.mRelocate = true;
 			bins.mFunction = true;
 			mIns.Push(bins);
 		}
 	}
-	else if (ins.mTType == IT_BOOL || ins.mTType == IT_INT8)
+	else if (ins->mTType == IT_BOOL || ins->mTType == IT_INT8)
 	{
 		ByteCodeInstruction	bins(BC_CONST_8);
-		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-		bins.mValue = ins.mIntValue;
+		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+		bins.mValue = ins->mIntValue;
 		mIns.Push(bins);
 	}
 	else
 	{
 		ByteCodeInstruction	bins(BC_CONST_16);
-		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-		bins.mValue = ins.mIntValue;
+		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+		bins.mValue = ins->mIntValue;
 		mIns.Push(bins);
 	}
 
 }
 
-void ByteCodeBasicBlock::CopyValue(InterCodeProcedure* proc, const InterInstruction& ins)
+void ByteCodeBasicBlock::CopyValue(InterCodeProcedure* proc, const InterInstruction * ins)
 {
 	ByteCodeInstruction	sins(BC_ADDR_REG);
-	sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-	sins.mRegisterFinal = ins.mSFinal[1];
+	sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+	sins.mRegisterFinal = ins->mSFinal[1];
 	mIns.Push(sins);
 	ByteCodeInstruction	dins(BC_LOAD_REG_16);
-	dins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-	dins.mRegisterFinal = ins.mSFinal[0];
+	dins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+	dins.mRegisterFinal = ins->mSFinal[0];
 	mIns.Push(dins);
 	ByteCodeInstruction	cins(BC_COPY);
-	cins.mValue = ins.mOperandSize;
+	cins.mValue = ins->mOperandSize;
 	mIns.Push(cins);
 }
 
-void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterInstruction& ins)
+void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	if (ins.mSType[0] == IT_FLOAT)
+	if (ins->mSType[0] == IT_FLOAT)
 	{
-		if (ins.mSTemp[1] < 0)
+		if (ins->mSTemp[1] < 0)
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				FloatConstToAccu(ins.mSFloatConst[0]);
+				FloatConstToAccu(ins->mSFloatConst[0]);
 
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
 					ByteCodeInstruction	bins(BC_STORE_ABS_32);
 					bins.mRelocate = true;
-					bins.mVIndex = ins.mVarIndex;
-					bins.mValue = ins.mSIntConst[1];
+					bins.mVIndex = ins->mVarIndex;
+					bins.mValue = ins->mSIntConst[1];
 					bins.mRegister = BC_REG_ACCU;
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
 					ByteCodeInstruction	bins(BC_STORE_ABS_32);
-					bins.mValue = ins.mSIntConst[1];
+					bins.mValue = ins->mSIntConst[1];
 					bins.mRegister = BC_REG_ACCU;
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[1];
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					int	index = ins->mSIntConst[1];
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 
 					if (index <= 252)
 					{
 						ByteCodeInstruction	bins(BC_STORE_LOCAL_32);
 						bins.mRegister = BC_REG_ACCU;
-						bins.mRegisterFinal = ins.mSFinal[0];
+						bins.mRegisterFinal = ins->mSFinal[0];
 						bins.mValue = index;
 						mIns.Push(bins);
 					}
@@ -714,51 +714,51 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 						mIns.Push(lins);
 						ByteCodeInstruction	bins(BC_STORE_ADDR_32);
 						bins.mRegister = BC_REG_ACCU;
-						bins.mRegisterFinal = ins.mSFinal[0];
+						bins.mRegisterFinal = ins->mSFinal[0];
 						bins.mValue = 0;
 						mIns.Push(bins);
 					}
 				}
-				else if (ins.mMemory == IM_FRAME)
+				else if (ins->mMemory == IM_FRAME)
 				{
 					ByteCodeInstruction	bins(BC_STORE_FRAME_32);
 					bins.mRegister = BC_REG_ACCU;
-					bins.mRegisterFinal = ins.mSFinal[0];
-					bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2;
+					bins.mRegisterFinal = ins->mSFinal[0];
+					bins.mValue = ins->mVarIndex + ins->mSIntConst[1] + 2;
 					mIns.Push(bins);
 				}
 			}
 			else
 			{
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
 					ByteCodeInstruction	bins(BC_STORE_ABS_32);
 					bins.mRelocate = true;
-					bins.mVIndex = ins.mVarIndex;
-					bins.mValue = ins.mSIntConst[1];
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
+					bins.mVIndex = ins->mVarIndex;
+					bins.mValue = ins->mSIntConst[1];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
 					ByteCodeInstruction	bins(BC_STORE_ABS_32);
-					bins.mValue = ins.mSIntConst[1];
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
+					bins.mValue = ins->mSIntConst[1];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[1];
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					int	index = ins->mSIntConst[1];
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 
 					if (index <= 252)
 					{
 						ByteCodeInstruction	bins(BC_STORE_LOCAL_32);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
 						bins.mValue = index;
 						mIns.Push(bins);
 					}
@@ -769,88 +769,88 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 						lins.mValue = index;
 						mIns.Push(lins);
 						ByteCodeInstruction	bins(BC_STORE_ADDR_32);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
 						bins.mValue = 0;
 						mIns.Push(bins);
 					}
 				}
-				else if (ins.mMemory == IM_FRAME)
+				else if (ins->mMemory == IM_FRAME)
 				{
 					ByteCodeInstruction	bins(BC_STORE_FRAME_32);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-					bins.mRegisterFinal = ins.mSFinal[0];
-					bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2;
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+					bins.mRegisterFinal = ins->mSFinal[0];
+					bins.mValue = ins->mVarIndex + ins->mSIntConst[1] + 2;
 					mIns.Push(bins);
 				}
 			}
 		}
 		else
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				FloatConstToAccu(ins.mSFloatConst[0]);
+				FloatConstToAccu(ins->mSFloatConst[0]);
 
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
 					ByteCodeInstruction	lins(BC_ADDR_REG);
-					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-					lins.mRegisterFinal = ins.mSFinal[1];
+					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+					lins.mRegisterFinal = ins->mSFinal[1];
 					mIns.Push(lins);
 					ByteCodeInstruction	bins(BC_STORE_ADDR_32);
 					bins.mRegister = BC_REG_ACCU;
-					bins.mValue = ins.mSIntConst[1];
+					bins.mValue = ins->mSIntConst[1];
 					mIns.Push(bins);
 				}
 			}
 			else
 			{
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
 					ByteCodeInstruction	lins(BC_ADDR_REG);
-					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-					lins.mRegisterFinal = ins.mSFinal[1];
+					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+					lins.mRegisterFinal = ins->mSFinal[1];
 					mIns.Push(lins);
 					ByteCodeInstruction	bins(BC_STORE_ADDR_32);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-					bins.mRegisterFinal = ins.mSFinal[0];
-					bins.mValue = ins.mSIntConst[1];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+					bins.mRegisterFinal = ins->mSFinal[0];
+					bins.mValue = ins->mSIntConst[1];
 					mIns.Push(bins);
 				}
 			}
 		}
 	}
-	else if (ins.mSType[0] == IT_POINTER)
+	else if (ins->mSType[0] == IT_POINTER)
 	{
-		if (ins.mSTemp[1] < 0)
+		if (ins->mSTemp[1] < 0)
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				IntConstToAccu(ins.mSIntConst[0]);
+				IntConstToAccu(ins->mSIntConst[0]);
 
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
 					ByteCodeInstruction	bins(BC_STORE_ABS_16);
 					bins.mRelocate = true;
-					bins.mVIndex = ins.mVarIndex;
-					bins.mValue = ins.mSIntConst[1];
+					bins.mVIndex = ins->mVarIndex;
+					bins.mValue = ins->mSIntConst[1];
 					bins.mRegister = BC_REG_ACCU;
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
 					ByteCodeInstruction	bins(BC_STORE_ABS_16);
-					bins.mValue = ins.mSIntConst[1];
+					bins.mValue = ins->mSIntConst[1];
 					bins.mRegister = BC_REG_ACCU;
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[1];
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					int	index = ins->mSIntConst[1];
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 
 					if (index <= 254)
 					{
@@ -871,46 +871,46 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 						mIns.Push(bins);
 					}
 				}
-				else if (ins.mMemory == IM_FRAME)
+				else if (ins->mMemory == IM_FRAME)
 				{
 					ByteCodeInstruction	bins(BC_STORE_FRAME_16);
 					bins.mRegister = BC_REG_ACCU;
-					bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2;
+					bins.mValue = ins->mVarIndex + ins->mSIntConst[1] + 2;
 					mIns.Push(bins);
 				}
 			}
 			else
 			{
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
 					ByteCodeInstruction	bins(BC_STORE_ABS_16);
 					bins.mRelocate = true;
-					bins.mVIndex = ins.mVarIndex;
-					bins.mValue = ins.mSIntConst[1];
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
+					bins.mVIndex = ins->mVarIndex;
+					bins.mValue = ins->mSIntConst[1];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
 					ByteCodeInstruction	bins(BC_STORE_ABS_16);
-					bins.mValue = ins.mSIntConst[1];
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-					bins.mRegisterFinal = ins.mSFinal[0];
+					bins.mValue = ins->mSIntConst[1];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+					bins.mRegisterFinal = ins->mSFinal[0];
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[1];
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					int	index = ins->mSIntConst[1];
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 
 					if (index <= 254)
 					{
 						ByteCodeInstruction	bins(BC_STORE_LOCAL_16);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
 						bins.mValue = index;
 						mIns.Push(bins);
 					}
@@ -921,52 +921,52 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 						lins.mValue = index;
 						mIns.Push(lins);
 						ByteCodeInstruction	bins(BC_STORE_ADDR_16);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
 						bins.mValue = 0;
 						mIns.Push(bins);
 					}
 				}
-				else if (ins.mMemory == IM_FRAME)
+				else if (ins->mMemory == IM_FRAME)
 				{
 					ByteCodeInstruction	bins(BC_STORE_FRAME_16);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-					bins.mRegisterFinal = ins.mSFinal[0];
-					bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2;
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+					bins.mRegisterFinal = ins->mSFinal[0];
+					bins.mValue = ins->mVarIndex + ins->mSIntConst[1] + 2;
 					mIns.Push(bins);
 				}
 			}
 		}
 		else
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				IntConstToAccu(ins.mSIntConst[0]);
+				IntConstToAccu(ins->mSIntConst[0]);
 
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
 					ByteCodeInstruction	lins(BC_ADDR_REG);
-					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-					lins.mRegisterFinal = ins.mSFinal[1];
+					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+					lins.mRegisterFinal = ins->mSFinal[1];
 					mIns.Push(lins);
 					ByteCodeInstruction	bins(BC_STORE_ADDR_16);
 					bins.mRegister = BC_REG_ACCU;
-					bins.mValue = ins.mSIntConst[1];
+					bins.mValue = ins->mSIntConst[1];
 					mIns.Push(bins);
 				}
 			}
 			else
 			{
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
 					ByteCodeInstruction	lins(BC_ADDR_REG);
-					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-					lins.mRegisterFinal = ins.mSFinal[1];
+					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+					lins.mRegisterFinal = ins->mSFinal[1];
 					mIns.Push(lins);
 					ByteCodeInstruction	bins(BC_STORE_ADDR_16);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-					bins.mRegisterFinal = ins.mSFinal[0];
-					bins.mValue = ins.mSIntConst[1];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+					bins.mRegisterFinal = ins->mSFinal[0];
+					bins.mValue = ins->mSIntConst[1];
 					mIns.Push(bins);
 				}
 			}
@@ -974,37 +974,37 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 	}
 	else
 	{
-		if (ins.mSTemp[1] < 0)
+		if (ins->mSTemp[1] < 0)
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				IntConstToAccu(ins.mSIntConst[0]);
+				IntConstToAccu(ins->mSIntConst[0]);
 
-				if (ins.mOperandSize == 1)
+				if (ins->mOperandSize == 1)
 				{
-					if (ins.mMemory == IM_GLOBAL)
+					if (ins->mMemory == IM_GLOBAL)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ABS_8);
 						bins.mRelocate = true;
-						bins.mVIndex = ins.mVarIndex;
-						bins.mValue = ins.mSIntConst[1];
+						bins.mVIndex = ins->mVarIndex;
+						bins.mValue = ins->mSIntConst[1];
 						bins.mRegister = BC_REG_ACCU;
 						mIns.Push(bins);
 					}
-					else if (ins.mMemory == IM_ABSOLUTE)
+					else if (ins->mMemory == IM_ABSOLUTE)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ABS_8);
-						bins.mValue = ins.mSIntConst[1];
+						bins.mValue = ins->mSIntConst[1];
 						bins.mRegister = BC_REG_ACCU;
 						mIns.Push(bins);
 					}
-					else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+					else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 					{
-						int	index = ins.mSIntConst[1];
-						if (ins.mMemory == IM_LOCAL)
-							index += proc->mLocalVars[ins.mVarIndex].mOffset;
+						int	index = ins->mSIntConst[1];
+						if (ins->mMemory == IM_LOCAL)
+							index += proc->mLocalVars[ins->mVarIndex].mOffset;
 						else
-							index += ins.mVarIndex + proc->mLocalSize + 2;
+							index += ins->mVarIndex + proc->mLocalSize + 2;
 
 						if (index <= 255)
 						{
@@ -1025,39 +1025,39 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 							mIns.Push(bins);
 						}
 					}
-					else if (ins.mMemory == IM_FRAME)
+					else if (ins->mMemory == IM_FRAME)
 					{
 						ByteCodeInstruction	bins(BC_STORE_FRAME_8);
 						bins.mRegister = BC_REG_ACCU;
-						bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2;
+						bins.mValue = ins->mVarIndex + ins->mSIntConst[1] + 2;
 						mIns.Push(bins);
 					}
 				}
-				else if (ins.mOperandSize == 2)
+				else if (ins->mOperandSize == 2)
 				{
-					if (ins.mMemory == IM_GLOBAL)
+					if (ins->mMemory == IM_GLOBAL)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ABS_16);
 						bins.mRelocate = true;
-						bins.mVIndex = ins.mVarIndex;
-						bins.mValue = ins.mSIntConst[1];
+						bins.mVIndex = ins->mVarIndex;
+						bins.mValue = ins->mSIntConst[1];
 						bins.mRegister = BC_REG_ACCU;
 						mIns.Push(bins);
 					}
-					else if (ins.mMemory == IM_ABSOLUTE)
+					else if (ins->mMemory == IM_ABSOLUTE)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ABS_16);
-						bins.mValue = ins.mSIntConst[1];
+						bins.mValue = ins->mSIntConst[1];
 						bins.mRegister = BC_REG_ACCU;
 						mIns.Push(bins);
 					}
-					else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+					else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 					{
-						int	index = ins.mSIntConst[1];
-						if (ins.mMemory == IM_LOCAL)
-							index += proc->mLocalVars[ins.mVarIndex].mOffset;
+						int	index = ins->mSIntConst[1];
+						if (ins->mMemory == IM_LOCAL)
+							index += proc->mLocalVars[ins->mVarIndex].mOffset;
 						else
-							index += ins.mVarIndex + proc->mLocalSize + 2;
+							index += ins->mVarIndex + proc->mLocalSize + 2;
 
 						if (index <= 254)
 						{
@@ -1078,50 +1078,50 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 							mIns.Push(bins);
 						}
 					}
-					else if (ins.mMemory == IM_FRAME)
+					else if (ins->mMemory == IM_FRAME)
 					{
 						ByteCodeInstruction	bins(BC_STORE_FRAME_16);
 						bins.mRegister = BC_REG_ACCU;
-						bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2;
+						bins.mValue = ins->mVarIndex + ins->mSIntConst[1] + 2;
 						mIns.Push(bins);
 					}
 				}
 			}
 			else
 			{
-				if (ins.mOperandSize == 1)
+				if (ins->mOperandSize == 1)
 				{
-					if (ins.mMemory == IM_GLOBAL)
+					if (ins->mMemory == IM_GLOBAL)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ABS_8);
 						bins.mRelocate = true;
-						bins.mVIndex = ins.mVarIndex;
-						bins.mValue = ins.mSIntConst[1];
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
+						bins.mVIndex = ins->mVarIndex;
+						bins.mValue = ins->mSIntConst[1];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
 						mIns.Push(bins);
 					}
-					else if (ins.mMemory == IM_ABSOLUTE)
+					else if (ins->mMemory == IM_ABSOLUTE)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ABS_8);
-						bins.mValue = ins.mSIntConst[1];
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
+						bins.mValue = ins->mSIntConst[1];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
 						mIns.Push(bins);
 					}
-					else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+					else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 					{
-						int	index = ins.mSIntConst[1];
-						if (ins.mMemory == IM_LOCAL)
-							index += proc->mLocalVars[ins.mVarIndex].mOffset;
+						int	index = ins->mSIntConst[1];
+						if (ins->mMemory == IM_LOCAL)
+							index += proc->mLocalVars[ins->mVarIndex].mOffset;
 						else
-							index += ins.mVarIndex + proc->mLocalSize + 2;
+							index += ins->mVarIndex + proc->mLocalSize + 2;
 
 						if (index <= 255)
 						{
 							ByteCodeInstruction	bins(BC_STORE_LOCAL_8);
-							bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-							bins.mRegisterFinal = ins.mSFinal[0];
+							bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+							bins.mRegisterFinal = ins->mSFinal[0];
 							bins.mValue = index;
 							mIns.Push(bins);
 						}
@@ -1132,54 +1132,54 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 							lins.mValue = index;
 							mIns.Push(lins);
 							ByteCodeInstruction	bins(BC_STORE_ADDR_8);
-							bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-							bins.mRegisterFinal = ins.mSFinal[0];
+							bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+							bins.mRegisterFinal = ins->mSFinal[0];
 							bins.mValue = 0;
 							mIns.Push(bins);
 						}
 					}
-					else if (ins.mMemory == IM_FRAME)
+					else if (ins->mMemory == IM_FRAME)
 					{
 						ByteCodeInstruction	bins(BC_STORE_FRAME_8);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
-						bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2;
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
+						bins.mValue = ins->mVarIndex + ins->mSIntConst[1] + 2;
 						mIns.Push(bins);
 					}
 				}
-				else if (ins.mOperandSize == 2)
+				else if (ins->mOperandSize == 2)
 				{
-					if (ins.mMemory == IM_GLOBAL)
+					if (ins->mMemory == IM_GLOBAL)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ABS_16);
 						bins.mRelocate = true;
-						bins.mVIndex = ins.mVarIndex;
-						bins.mValue = ins.mSIntConst[1];
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
+						bins.mVIndex = ins->mVarIndex;
+						bins.mValue = ins->mSIntConst[1];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
 						mIns.Push(bins);
 					}
-					else if (ins.mMemory == IM_ABSOLUTE)
+					else if (ins->mMemory == IM_ABSOLUTE)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ABS_16);
-						bins.mValue = ins.mSIntConst[1];
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
+						bins.mValue = ins->mSIntConst[1];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
 						mIns.Push(bins);
 					}
-					else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+					else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 					{
-						int	index = ins.mSIntConst[1];
-						if (ins.mMemory == IM_LOCAL)
-							index += proc->mLocalVars[ins.mVarIndex].mOffset;
+						int	index = ins->mSIntConst[1];
+						if (ins->mMemory == IM_LOCAL)
+							index += proc->mLocalVars[ins->mVarIndex].mOffset;
 						else
-							index += ins.mVarIndex + proc->mLocalSize + 2;
+							index += ins->mVarIndex + proc->mLocalSize + 2;
 
 						if (index <= 254)
 						{
 							ByteCodeInstruction	bins(BC_STORE_LOCAL_16);
-							bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-							bins.mRegisterFinal = ins.mSFinal[0];
+							bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+							bins.mRegisterFinal = ins->mSFinal[0];
 							bins.mValue = index;
 							mIns.Push(bins);
 						}
@@ -1190,18 +1190,18 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 							lins.mValue = index;
 							mIns.Push(lins);
 							ByteCodeInstruction	bins(BC_STORE_ADDR_16);
-							bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-							bins.mRegisterFinal = ins.mSFinal[0];
+							bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+							bins.mRegisterFinal = ins->mSFinal[0];
 							bins.mValue = 0;
 							mIns.Push(bins);
 						}
 					}
-					else if (ins.mMemory == IM_FRAME)
+					else if (ins->mMemory == IM_FRAME)
 					{
 						ByteCodeInstruction	bins(BC_STORE_FRAME_16);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
-						bins.mValue = ins.mVarIndex + ins.mSIntConst[1] + 2;
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
+						bins.mValue = ins->mVarIndex + ins->mSIntConst[1] + 2;
 						mIns.Push(bins);
 					}
 				}
@@ -1209,54 +1209,54 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 		}
 		else
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				IntConstToAccu(ins.mSIntConst[0]);
+				IntConstToAccu(ins->mSIntConst[0]);
 
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
 					ByteCodeInstruction	lins(BC_ADDR_REG);
-					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-					lins.mRegisterFinal = ins.mSFinal[1];
+					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+					lins.mRegisterFinal = ins->mSFinal[1];
 					mIns.Push(lins);
-					if (ins.mOperandSize == 1)
+					if (ins->mOperandSize == 1)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ADDR_8);
 						bins.mRegister = BC_REG_ACCU;
-						bins.mValue = ins.mSIntConst[1];
+						bins.mValue = ins->mSIntConst[1];
 						mIns.Push(bins);
 					}
-					else if (ins.mOperandSize == 2)
+					else if (ins->mOperandSize == 2)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ADDR_16);
 						bins.mRegister = BC_REG_ACCU;
-						bins.mValue = ins.mSIntConst[1];
+						bins.mValue = ins->mSIntConst[1];
 						mIns.Push(bins);
 					}
 				}
 			}
 			else
 			{
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
 					ByteCodeInstruction	lins(BC_ADDR_REG);
-					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-					lins.mRegisterFinal = ins.mSFinal[1];
+					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+					lins.mRegisterFinal = ins->mSFinal[1];
 					mIns.Push(lins);
-					if (ins.mOperandSize == 1)
+					if (ins->mOperandSize == 1)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ADDR_8);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
-						bins.mValue = ins.mSIntConst[1];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
+						bins.mValue = ins->mSIntConst[1];
 						mIns.Push(bins);
 					}
-					else if (ins.mOperandSize == 2)
+					else if (ins->mOperandSize == 2)
 					{
 						ByteCodeInstruction	bins(BC_STORE_ADDR_16);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
-						bins.mValue = ins.mSIntConst[1];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
+						bins.mValue = ins->mSIntConst[1];
 						mIns.Push(bins);
 					}
 				}
@@ -1265,40 +1265,40 @@ void ByteCodeBasicBlock::StoreDirectValue(InterCodeProcedure* proc, const InterI
 	}
 }
 
-void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterInstruction& ins)
+void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	if (ins.mTType == IT_FLOAT)
+	if (ins->mTType == IT_FLOAT)
 	{
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{
-			if (ins.mMemory == IM_GLOBAL)
+			if (ins->mMemory == IM_GLOBAL)
 			{
 				ByteCodeInstruction	bins(BC_LOAD_ABS_32);
 				bins.mRelocate = true;
-				bins.mVIndex = ins.mVarIndex;
-				bins.mValue = ins.mSIntConst[0];
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+				bins.mVIndex = ins->mVarIndex;
+				bins.mValue = ins->mSIntConst[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 				mIns.Push(bins);
 			}
-			else if (ins.mMemory == IM_ABSOLUTE)
+			else if (ins->mMemory == IM_ABSOLUTE)
 			{
 				ByteCodeInstruction	bins(BC_LOAD_ABS_32);
-				bins.mValue = ins.mSIntConst[0];
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+				bins.mValue = ins->mSIntConst[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 				mIns.Push(bins);
 			}
-			else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+			else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 			{
-				int	index = ins.mSIntConst[0];
-				if (ins.mMemory == IM_LOCAL)
-					index += proc->mLocalVars[ins.mVarIndex].mOffset;
+				int	index = ins->mSIntConst[0];
+				if (ins->mMemory == IM_LOCAL)
+					index += proc->mLocalVars[ins->mVarIndex].mOffset;
 				else
-					index += ins.mVarIndex + proc->mLocalSize + 2;
+					index += ins->mVarIndex + proc->mLocalSize + 2;
 
 				if (index <= 254)
 				{
 					ByteCodeInstruction	bins(BC_LOAD_LOCAL_32);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 					bins.mValue = index;
 					mIns.Push(bins);
 				}
@@ -1309,7 +1309,7 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn
 					lins.mValue = index;
 					mIns.Push(lins);
 					ByteCodeInstruction	bins(BC_LOAD_ADDR_32);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 					bins.mValue = 0;
 					mIns.Push(bins);
 				}
@@ -1317,51 +1317,51 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn
 		}
 		else
 		{
-			if (ins.mMemory == IM_INDIRECT)
+			if (ins->mMemory == IM_INDIRECT)
 			{
 				ByteCodeInstruction	lins(BC_ADDR_REG);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				lins.mRegisterFinal = ins.mSFinal[0];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				lins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(lins);
 				ByteCodeInstruction	bins(BC_LOAD_ADDR_32);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-				bins.mValue = ins.mSIntConst[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+				bins.mValue = ins->mSIntConst[0];
 				mIns.Push(bins);
 			}
 		}
 	}
-	else if (ins.mTType == IT_POINTER)
+	else if (ins->mTType == IT_POINTER)
 	{
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{
-			if (ins.mMemory == IM_GLOBAL)
+			if (ins->mMemory == IM_GLOBAL)
 			{
 				ByteCodeInstruction	bins(BC_LOAD_ABS_16);
 				bins.mRelocate = true;
-				bins.mVIndex = ins.mVarIndex;
-				bins.mValue = ins.mSIntConst[0];
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+				bins.mVIndex = ins->mVarIndex;
+				bins.mValue = ins->mSIntConst[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 				mIns.Push(bins);
 			}
-			else if (ins.mMemory == IM_ABSOLUTE)
+			else if (ins->mMemory == IM_ABSOLUTE)
 			{
 				ByteCodeInstruction	bins(BC_LOAD_ABS_16);
-				bins.mValue = ins.mSIntConst[0];
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+				bins.mValue = ins->mSIntConst[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 				mIns.Push(bins);
 			}
-			else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+			else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 			{
-				int	index = ins.mSIntConst[0];
-				if (ins.mMemory == IM_LOCAL)
-					index += proc->mLocalVars[ins.mVarIndex].mOffset;
+				int	index = ins->mSIntConst[0];
+				if (ins->mMemory == IM_LOCAL)
+					index += proc->mLocalVars[ins->mVarIndex].mOffset;
 				else
-					index += ins.mVarIndex + proc->mLocalSize + 2;
+					index += ins->mVarIndex + proc->mLocalSize + 2;
 
 				if (index <= 254)
 				{
 					ByteCodeInstruction	bins(BC_LOAD_LOCAL_16);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 					bins.mValue = index;
 					mIns.Push(bins);
 				}
@@ -1372,7 +1372,7 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn
 					lins.mValue = index;
 					mIns.Push(lins);
 					ByteCodeInstruction	bins(BC_LOAD_ADDR_16);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 					bins.mValue = 0;
 					mIns.Push(bins);
 				}
@@ -1380,53 +1380,53 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn
 		}
 		else
 		{
-			if (ins.mMemory == IM_INDIRECT)
+			if (ins->mMemory == IM_INDIRECT)
 			{
 				ByteCodeInstruction	lins(BC_ADDR_REG);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				lins.mRegisterFinal = ins.mSFinal[0];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				lins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(lins);
 				ByteCodeInstruction	bins(BC_LOAD_ADDR_16);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-				bins.mValue = ins.mSIntConst[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+				bins.mValue = ins->mSIntConst[0];
 				mIns.Push(bins);
 			}
 		}
 	}
 	else
 	{
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{ 
-			if (ins.mOperandSize == 1)
+			if (ins->mOperandSize == 1)
 			{
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
-					ByteCodeInstruction	bins((ins.mTType == IT_BOOL || ins.mTType == IT_INT8) ? BC_LOAD_ABS_8 : BC_LOAD_ABS_U8);
+					ByteCodeInstruction	bins((ins->mTType == IT_BOOL || ins->mTType == IT_INT8) ? BC_LOAD_ABS_8 : BC_LOAD_ABS_U8);
 					bins.mRelocate = true;
-					bins.mVIndex = ins.mVarIndex;
-					bins.mValue = ins.mSIntConst[0];
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+					bins.mVIndex = ins->mVarIndex;
+					bins.mValue = ins->mSIntConst[0];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
-					ByteCodeInstruction	bins((ins.mTType == IT_BOOL || ins.mTType == IT_INT8) ? BC_LOAD_ABS_8 : BC_LOAD_ABS_U8);
-					bins.mValue = ins.mSIntConst[0];
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+					ByteCodeInstruction	bins((ins->mTType == IT_BOOL || ins->mTType == IT_INT8) ? BC_LOAD_ABS_8 : BC_LOAD_ABS_U8);
+					bins.mValue = ins->mSIntConst[0];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[0];
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					int	index = ins->mSIntConst[0];
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 
 					if (index <= 255)
 					{
-						ByteCodeInstruction	bins((ins.mTType == IT_BOOL || ins.mTType == IT_INT8) ? BC_LOAD_LOCAL_8 : BC_LOAD_LOCAL_U8);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+						ByteCodeInstruction	bins((ins->mTType == IT_BOOL || ins->mTType == IT_INT8) ? BC_LOAD_LOCAL_8 : BC_LOAD_LOCAL_U8);
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 						bins.mValue = index;
 						mIns.Push(bins);
 					}
@@ -1436,43 +1436,43 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn
 						lins.mRegister = BC_REG_ADDR;
 						lins.mValue = index;
 						mIns.Push(lins);
-						ByteCodeInstruction	bins((ins.mTType == IT_BOOL || ins.mTType == IT_INT8) ? BC_LOAD_LOCAL_8 : BC_LOAD_ADDR_U8);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+						ByteCodeInstruction	bins((ins->mTType == IT_BOOL || ins->mTType == IT_INT8) ? BC_LOAD_LOCAL_8 : BC_LOAD_ADDR_U8);
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 						bins.mValue = 0;
 						mIns.Push(bins);
 					}
 				}
 			}
-			else if (ins.mOperandSize == 2)
+			else if (ins->mOperandSize == 2)
 			{
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
 					ByteCodeInstruction	bins(BC_LOAD_ABS_16);
 					bins.mRelocate = true;
-					bins.mVIndex = ins.mVarIndex;
-					bins.mValue = ins.mSIntConst[0];
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+					bins.mVIndex = ins->mVarIndex;
+					bins.mValue = ins->mSIntConst[0];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
 					ByteCodeInstruction	bins(BC_LOAD_ABS_16);
-					bins.mValue = ins.mSIntConst[0];
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+					bins.mValue = ins->mSIntConst[0];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 					mIns.Push(bins);
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[0];
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					int	index = ins->mSIntConst[0];
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 
 					if (index <= 254)
 					{
 						ByteCodeInstruction	bins(BC_LOAD_LOCAL_16);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 						bins.mValue = index;
 						mIns.Push(bins);
 					}
@@ -1483,7 +1483,7 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn
 						lins.mValue = index;
 						mIns.Push(lins);
 						ByteCodeInstruction	bins(BC_LOAD_ADDR_16);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 						bins.mValue = 0;
 						mIns.Push(bins);
 					}
@@ -1492,25 +1492,25 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn
 		}
 		else
 		{
-			if (ins.mMemory == IM_INDIRECT)
+			if (ins->mMemory == IM_INDIRECT)
 			{
 				ByteCodeInstruction	lins(BC_ADDR_REG);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				lins.mRegisterFinal = ins.mSFinal[0];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				lins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(lins);
 
-				if (ins.mOperandSize == 1)
+				if (ins->mOperandSize == 1)
 				{
-					ByteCodeInstruction	bins((ins.mTType == IT_BOOL || ins.mTType == IT_INT8) ? BC_LOAD_ADDR_8 : BC_LOAD_ADDR_U8);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-					bins.mValue = ins.mSIntConst[0];
+					ByteCodeInstruction	bins((ins->mTType == IT_BOOL || ins->mTType == IT_INT8) ? BC_LOAD_ADDR_8 : BC_LOAD_ADDR_U8);
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+					bins.mValue = ins->mSIntConst[0];
 					mIns.Push(bins);
 				}
-				else if (ins.mOperandSize == 2)
+				else if (ins->mOperandSize == 2)
 				{
 					ByteCodeInstruction	bins(BC_LOAD_ADDR_16);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-					bins.mValue = ins.mSIntConst[0];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+					bins.mValue = ins->mSIntConst[0];
 					mIns.Push(bins);
 				}
 			}
@@ -1518,55 +1518,55 @@ void ByteCodeBasicBlock::LoadDirectValue(InterCodeProcedure* proc, const InterIn
 	}
 }
 
-void ByteCodeBasicBlock::LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction& ins)
+void ByteCodeBasicBlock::LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	if (ins.mSTemp[0] < 0)
+	if (ins->mSTemp[0] < 0)
 	{
-		if (ins.mSTemp[1] == ins.mTTemp)
+		if (ins->mSTemp[1] == ins->mTTemp)
 		{
 			ByteCodeInstruction	bins(BC_BINOP_ADDI_16);
-			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-			bins.mValue = ins.mSIntConst[0];
+			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+			bins.mValue = ins->mSIntConst[0];
 			mIns.Push(bins);
 		}
 		else
 		{
 			ByteCodeInstruction	lins(BC_LOAD_REG_16);
-			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-			lins.mRegisterFinal = ins.mSFinal[1];
+			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+			lins.mRegisterFinal = ins->mSFinal[1];
 			mIns.Push(lins);
 			ByteCodeInstruction	ains(BC_BINOP_ADDI_16);
 			ains.mRegister = BC_REG_ACCU;
-			ains.mValue = ins.mSIntConst[0];
+			ains.mValue = ins->mSIntConst[0];
 			mIns.Push(ains);
 			ByteCodeInstruction	sins(BC_STORE_REG_16);
-			sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+			sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 			mIns.Push(sins);
 		}
 	}
 	else
 	{
 		ByteCodeInstruction	lins(BC_LOAD_REG_16);
-		lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-		lins.mRegisterFinal = ins.mSFinal[1];
+		lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+		lins.mRegisterFinal = ins->mSFinal[1];
 		mIns.Push(lins);
 		ByteCodeInstruction	ains(BC_BINOP_ADDR_16);
-		ains.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-		ains.mRegisterFinal = ins.mSFinal[0];
+		ains.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+		ains.mRegisterFinal = ins->mSFinal[0];
 		mIns.Push(ains);
 		ByteCodeInstruction	sins(BC_STORE_REG_16);
-		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 		mIns.Push(sins);
 	}
 }
-void ByteCodeBasicBlock::CallFunction(InterCodeProcedure* proc, const InterInstruction& ins)
+void ByteCodeBasicBlock::CallFunction(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	if (ins.mSTemp[0] < 0)
+	if (ins->mSTemp[0] < 0)
 	{
 		ByteCodeInstruction	bins(BC_LEA_ABS);
 		bins.mRelocate = true;
 		bins.mFunction = true;
-		bins.mVIndex = ins.mVarIndex;
+		bins.mVIndex = ins->mVarIndex;
 		bins.mValue = 0;
 		bins.mRegister = BC_REG_ADDR;
 		mIns.Push(bins);
@@ -1574,48 +1574,48 @@ void ByteCodeBasicBlock::CallFunction(InterCodeProcedure* proc, const InterInstr
 	else
 	{
 		ByteCodeInstruction	bins(BC_ADDR_REG);
-		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-		bins.mRegisterFinal = ins.mSFinal[0];
+		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+		bins.mRegisterFinal = ins->mSFinal[0];
 		mIns.Push(bins);
 	}
 
 	ByteCodeInstruction	cins(BC_CALL);
 	mIns.Push(cins);
 
-	if (ins.mTTemp >= 0)
+	if (ins->mTTemp >= 0)
 	{
-		ByteCodeInstruction	bins(StoreTypedTmpCodes[ins.mTType]);
-		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+		ByteCodeInstruction	bins(StoreTypedTmpCodes[ins->mTType]);
+		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 		mIns.Push(bins);
 	}
 }
 
-void ByteCodeBasicBlock::CallAssembler(InterCodeProcedure* proc, const InterInstruction& ins)
+void ByteCodeBasicBlock::CallAssembler(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	if (ins.mSTemp[0] < 0)
+	if (ins->mSTemp[0] < 0)
 	{
 		ByteCodeInstruction	bins(BC_JSR);
 		bins.mRelocate = true;
-		bins.mVIndex = ins.mVarIndex;
-		bins.mFunction = ins.mMemory == IM_PROCEDURE;
-		bins.mValue = ins.mSIntConst[0];
+		bins.mVIndex = ins->mVarIndex;
+		bins.mFunction = ins->mMemory == IM_PROCEDURE;
+		bins.mValue = ins->mSIntConst[0];
 		mIns.Push(bins);
 	}
 
-	if (ins.mTTemp >= 0)
+	if (ins->mTTemp >= 0)
 	{
-		ByteCodeInstruction	bins(StoreTypedTmpCodes[ins.mTType]);
-		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+		ByteCodeInstruction	bins(StoreTypedTmpCodes[ins->mTType]);
+		bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 		mIns.Push(bins);
 	}
 }
 
-ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const InterInstruction& ins)
+ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const InterInstruction * ins)
 {
 	ByteCode	code;
 	bool		csigned = false;
 
-	switch (ins.mOperator)
+	switch (ins->mOperator)
 	{
 	default:
 	case IA_CMPEQ:
@@ -1655,72 +1655,72 @@ ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const
 		break;
 	}
 
-	if (ins.mSType[0] == IT_FLOAT)
+	if (ins->mSType[0] == IT_FLOAT)
 	{
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{
-			FloatConstToAccu(ins.mSFloatConst[0]);
+			FloatConstToAccu(ins->mSFloatConst[0]);
 		}
 		else
 		{
 			ByteCodeInstruction	lins(BC_LOAD_REG_32);
-			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-			lins.mRegisterFinal = ins.mSFinal[0];
+			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+			lins.mRegisterFinal = ins->mSFinal[0];
 			mIns.Push(lins);
 		}
 
 		ByteCodeInstruction	cins(BC_BINOP_CMP_F32);
 
-		if (ins.mSTemp[1] < 0)
+		if (ins->mSTemp[1] < 0)
 		{
-			FloatConstToWork(ins.mSFloatConst[1]);
+			FloatConstToWork(ins->mSFloatConst[1]);
 			cins.mRegister = BC_REG_WORK;
 		}
 		else
 		{
-			cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
+			cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
 		}
 
-		cins.mRegisterFinal = ins.mSFinal[1];
+		cins.mRegisterFinal = ins->mSFinal[1];
 		mIns.Push(cins);
 	}
 	else
 	{
-		if (ins.mSTemp[1] < 0)
+		if (ins->mSTemp[1] < 0)
 		{
 			ByteCodeInstruction	lins(BC_LOAD_REG_16);
-			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-			lins.mRegisterFinal = ins.mSFinal[0];
+			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+			lins.mRegisterFinal = ins->mSFinal[0];
 			mIns.Push(lins);
 			if (csigned)
 			{
 				ByteCodeInstruction	cins(BC_BINOP_CMPSI_16);
-				cins.mValue = ins.mSIntConst[1];
+				cins.mValue = ins->mSIntConst[1];
 				mIns.Push(cins);
 			}
 			else
 			{
 				ByteCodeInstruction	cins(BC_BINOP_CMPUI_16);
-				cins.mValue = ins.mSIntConst[1];
+				cins.mValue = ins->mSIntConst[1];
 				mIns.Push(cins);
 			}
 		}
-		else if (ins.mSTemp[0] < 0)
+		else if (ins->mSTemp[0] < 0)
 		{
 			ByteCodeInstruction	lins(BC_LOAD_REG_16);
-			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-			lins.mRegisterFinal = ins.mSFinal[1];
+			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+			lins.mRegisterFinal = ins->mSFinal[1];
 			mIns.Push(lins);
 			if (csigned)
 			{
 				ByteCodeInstruction	cins(BC_BINOP_CMPSI_16);
-				cins.mValue = ins.mSIntConst[0];
+				cins.mValue = ins->mSIntConst[0];
 				mIns.Push(cins);
 			}
 			else
 			{
 				ByteCodeInstruction	cins(BC_BINOP_CMPUI_16);
-				cins.mValue = ins.mSIntConst[0];
+				cins.mValue = ins->mSIntConst[0];
 				mIns.Push(cins);
 			}
 			code = TransposeBranchCondition(code);
@@ -1728,21 +1728,21 @@ ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const
 		else
 		{
 			ByteCodeInstruction	lins(BC_LOAD_REG_16);
-			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-			lins.mRegisterFinal = ins.mSFinal[0];
+			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+			lins.mRegisterFinal = ins->mSFinal[0];
 			mIns.Push(lins);
 			if (csigned)
 			{
 				ByteCodeInstruction	cins(BC_BINOP_CMPSR_16);
-				cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				cins.mRegisterFinal = ins.mSFinal[1];
+				cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				cins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(cins);
 			}
 			else
 			{
 				ByteCodeInstruction	cins(BC_BINOP_CMPUR_16);
-				cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				cins.mRegisterFinal = ins.mSFinal[1];
+				cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				cins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(cins);
 			}
 		}
@@ -1751,11 +1751,11 @@ ByteCode ByteCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const
 	return code;
 }
 
-static ByteCode ByteCodeBinRegOperator(const InterInstruction& ins)
+static ByteCode ByteCodeBinRegOperator(const InterInstruction * ins)
 {
-	if (ins.mTType == IT_FLOAT)
+	if (ins->mTType == IT_FLOAT)
 	{
-		switch (ins.mOperator)
+		switch (ins->mOperator)
 		{
 		case IA_ADD: return BC_BINOP_ADD_F32;
 		case IA_SUB: return BC_BINOP_SUB_F32;
@@ -1769,7 +1769,7 @@ static ByteCode ByteCodeBinRegOperator(const InterInstruction& ins)
 	}
 	else
 	{
-		switch (ins.mOperator)
+		switch (ins->mOperator)
 		{
 		case IA_ADD: return BC_BINOP_ADDR_16;
 		case IA_SUB: return BC_BINOP_SUBR_16;
@@ -1792,9 +1792,9 @@ static ByteCode ByteCodeBinRegOperator(const InterInstruction& ins)
 	}
 }
 
-static ByteCode ByteCodeBinImmOperator(const InterInstruction& ins)
+static ByteCode ByteCodeBinImmOperator(const InterInstruction * ins)
 {
-	switch (ins.mOperator)
+	switch (ins->mOperator)
 	{
 	case IA_ADD: return BC_BINOP_ADDI_16;
 	case IA_SUB: return BC_BINOP_SUBI_16;
@@ -1810,31 +1810,31 @@ static ByteCode ByteCodeBinImmOperator(const InterInstruction& ins)
 	}
 }
 
-void ByteCodeBasicBlock::NumericConversion(InterCodeProcedure* proc, const InterInstruction& ins)
+void ByteCodeBasicBlock::NumericConversion(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	switch (ins.mOperator)
+	switch (ins->mOperator)
 	{
 	case IA_FLOAT2INT:
 	{
 		ByteCodeInstruction	lins(BC_LOAD_REG_32);
-		lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-		lins.mRegisterFinal = ins.mSFinal[0];
+		lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+		lins.mRegisterFinal = ins->mSFinal[0];
 		mIns.Push(lins);
 
 		ByteCodeInstruction	bins(BC_CONV_F32_I16);
-//		ByteCodeInstruction	bins(ins.mTType == IT_SIGNED ? BC_CONV_F32_I16 : BC_CONV_F32_U16);
+//		ByteCodeInstruction	bins(ins->mTType == IT_SIGNED ? BC_CONV_F32_I16 : BC_CONV_F32_U16);
 		mIns.Push(bins);
 
 		ByteCodeInstruction	sins(BC_STORE_REG_16);
-		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 		mIns.Push(sins);
 
 	}	break;
 	case IA_INT2FLOAT:
 	{
 		ByteCodeInstruction	lins(BC_LOAD_REG_16);
-		lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-		lins.mRegisterFinal = ins.mSFinal[0];
+		lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+		lins.mRegisterFinal = ins->mSFinal[0];
 		mIns.Push(lins);
 
 		ByteCodeInstruction	bins(BC_CONV_I16_F32);
@@ -1842,24 +1842,24 @@ void ByteCodeBasicBlock::NumericConversion(InterCodeProcedure* proc, const Inter
 		mIns.Push(bins);
 
 		ByteCodeInstruction	sins(BC_STORE_REG_32);
-		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 		mIns.Push(sins);
 
 	} break;
 	case IA_EXT8TO16S:
 	{
-		if (ins.mSTemp[0] == ins.mTTemp)
+		if (ins->mSTemp[0] == ins->mTTemp)
 		{
 			ByteCodeInstruction	cins(BC_CONV_I8_I16);
-			cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-			cins.mRegisterFinal = ins.mSFinal[0];
+			cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+			cins.mRegisterFinal = ins->mSFinal[0];
 			mIns.Push(cins);
 		}
 		else
 		{
 			ByteCodeInstruction	lins(BC_LOAD_REG_8);
-			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-			lins.mRegisterFinal = ins.mSFinal[0];
+			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+			lins.mRegisterFinal = ins->mSFinal[0];
 			mIns.Push(lins);
 
 			ByteCodeInstruction	cins(BC_CONV_I8_I16);
@@ -1867,29 +1867,29 @@ void ByteCodeBasicBlock::NumericConversion(InterCodeProcedure* proc, const Inter
 			mIns.Push(cins);
 
 			ByteCodeInstruction	sins(BC_STORE_REG_16);
-			sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+			sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 			mIns.Push(sins);
 		}
 	}	break;
 	case IA_EXT8TO16U:
 	{
-		if (ins.mSTemp[0] == ins.mTTemp)
+		if (ins->mSTemp[0] == ins->mTTemp)
 		{
 			ByteCodeInstruction	cins(BC_BINOP_ANDI_16);
-			cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-			cins.mRegisterFinal = ins.mSFinal[0];
+			cins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+			cins.mRegisterFinal = ins->mSFinal[0];
 			cins.mValue = 0x00ff;
 			mIns.Push(cins);
 		}
 		else
 		{
 			ByteCodeInstruction	lins(BC_LOAD_REG_8);
-			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-			lins.mRegisterFinal = ins.mSFinal[0];
+			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+			lins.mRegisterFinal = ins->mSFinal[0];
 			mIns.Push(lins);
 
 			ByteCodeInstruction	sins(BC_STORE_REG_16);
-			sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+			sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 			mIns.Push(sins);
 		}
 	}	break;
@@ -1897,16 +1897,16 @@ void ByteCodeBasicBlock::NumericConversion(InterCodeProcedure* proc, const Inter
 	}
 }
 
-void ByteCodeBasicBlock::UnaryOperator(InterCodeProcedure* proc, const InterInstruction& ins)
+void ByteCodeBasicBlock::UnaryOperator(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	if (ins.mTType == IT_FLOAT)
+	if (ins->mTType == IT_FLOAT)
 	{
 		ByteCodeInstruction	lins(BC_LOAD_REG_32);
-		lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-		lins.mRegisterFinal = ins.mSFinal[0];
+		lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+		lins.mRegisterFinal = ins->mSFinal[0];
 		mIns.Push(lins);
 
-		switch (ins.mOperator)
+		switch (ins->mOperator)
 		{
 		case IA_NEG:
 		{
@@ -1931,17 +1931,17 @@ void ByteCodeBasicBlock::UnaryOperator(InterCodeProcedure* proc, const InterInst
 		}
 
 		ByteCodeInstruction	sins(BC_STORE_REG_32);
-		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 		mIns.Push(sins);
 	}
 	else
 	{
 		ByteCodeInstruction	lins(BC_LOAD_REG_16);
-		lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-		lins.mRegisterFinal = ins.mSFinal[0];
+		lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+		lins.mRegisterFinal = ins->mSFinal[0];
 		mIns.Push(lins);
 
-		switch (ins.mOperator)
+		switch (ins->mOperator)
 		{
 		case IA_NEG:
 		{
@@ -1957,51 +1957,51 @@ void ByteCodeBasicBlock::UnaryOperator(InterCodeProcedure* proc, const InterInst
 		}
 
 		ByteCodeInstruction	sins(BC_STORE_REG_16);
-		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 		mIns.Push(sins);
 	}
 }
 
-void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterInstruction& ins)
+void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	if (ins.mTType == IT_FLOAT)
+	if (ins->mTType == IT_FLOAT)
 	{
 		ByteCode	bc = ByteCodeBinRegOperator(ins);
 
-		if (ins.mSTemp[1] < 0)
+		if (ins->mSTemp[1] < 0)
 		{
-			FloatConstToAccu(ins.mSFloatConst[1]);
+			FloatConstToAccu(ins->mSFloatConst[1]);
 		}
 		else
 		{
 			ByteCodeInstruction	lins(BC_LOAD_REG_32);
-			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-			lins.mRegisterFinal = ins.mSFinal[1];
+			lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+			lins.mRegisterFinal = ins->mSFinal[1];
 			mIns.Push(lins);
 		}
 
 		ByteCodeInstruction	bins(bc);
 
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{
-			FloatConstToWork(ins.mSFloatConst[0]);
+			FloatConstToWork(ins->mSFloatConst[0]);
 			bins.mRegister = BC_REG_WORK;
 		}
-		else if (ins.mSTemp[1] == ins.mSTemp[0])
+		else if (ins->mSTemp[1] == ins->mSTemp[0])
 			bins.mRegister = BC_REG_ACCU;
 		else
-			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
+			bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
 
-		bins.mRegisterFinal = ins.mSFinal[0];
+		bins.mRegisterFinal = ins->mSFinal[0];
 		mIns.Push(bins);
 
 		ByteCodeInstruction	sins(BC_STORE_REG_32);
-		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 		mIns.Push(sins);
 	}
 	else
 	{
-		switch (ins.mOperator)
+		switch (ins->mOperator)
 		{
 		case IA_ADD:
 		case IA_OR:
@@ -2010,113 +2010,113 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns
 			ByteCode	bc = ByteCodeBinRegOperator(ins);
 			ByteCode	bci = ByteCodeBinImmOperator(ins);
 
-			if (ins.mSTemp[1] < 0)
+			if (ins->mSTemp[1] < 0)
 			{
-				if (ins.mSTemp[0] == ins.mTTemp)
+				if (ins->mSTemp[0] == ins->mTTemp)
 				{
 					ByteCodeInstruction	bins(bci);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-					bins.mValue = ins.mSIntConst[1];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+					bins.mValue = ins->mSIntConst[1];
 					mIns.Push(bins);
 					return;
 				}
 
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				lins.mRegisterFinal = ins.mSFinal[0];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				lins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(bci);
 				bins.mRegister = BC_REG_ACCU;
-				bins.mValue = ins.mSIntConst[1];
+				bins.mValue = ins->mSIntConst[1];
 				mIns.Push(bins);
 			}
-			else if (ins.mSTemp[0] < 0)
+			else if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mSTemp[1] == ins.mTTemp)
+				if (ins->mSTemp[1] == ins->mTTemp)
 				{
 					ByteCodeInstruction	bins(bci);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-					bins.mValue = ins.mSIntConst[0];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+					bins.mValue = ins->mSIntConst[0];
 					mIns.Push(bins);
 					return;
 				}
 
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				lins.mRegisterFinal = ins.mSFinal[1];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				lins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(bci);
 				bins.mRegister = BC_REG_ACCU;
-				bins.mValue = ins.mSIntConst[0];
+				bins.mValue = ins->mSIntConst[0];
 				mIns.Push(bins);
 			}
 			else
 			{
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				lins.mRegisterFinal = ins.mSFinal[1];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				lins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(bc);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				bins.mRegisterFinal = ins.mSFinal[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				bins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(bins);
 			}
 		}
 			break;
 		case IA_SUB:
-			if (ins.mSTemp[1] < 0)
+			if (ins->mSTemp[1] < 0)
 			{
-				if (ins.mSTemp[0] == ins.mTTemp)
+				if (ins->mSTemp[0] == ins->mTTemp)
 				{
 					ByteCodeInstruction	bins(BC_BINOP_SUBI_16);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-					bins.mValue = ins.mSIntConst[1];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+					bins.mValue = ins->mSIntConst[1];
 					mIns.Push(bins);
 					return;
 				}
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				lins.mRegisterFinal = ins.mSFinal[0];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				lins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(BC_BINOP_SUBI_16);
 				bins.mRegister = BC_REG_ACCU;
-				bins.mValue = ins.mSIntConst[1];
+				bins.mValue = ins->mSIntConst[1];
 				mIns.Push(bins);
 			}
-			else if (ins.mSTemp[0] < 0)
+			else if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mSTemp[1] == ins.mTTemp)
+				if (ins->mSTemp[1] == ins->mTTemp)
 				{
 					ByteCodeInstruction	bins(BC_BINOP_ADDI_16);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
-					bins.mValue = - ins.mSIntConst[0];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
+					bins.mValue = - ins->mSIntConst[0];
 					mIns.Push(bins);
 					return;
 				}
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				lins.mRegisterFinal = ins.mSFinal[1];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				lins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(BC_BINOP_ADDI_16);
 				bins.mRegister = BC_REG_ACCU;
-				bins.mValue = - ins.mSIntConst[0];
+				bins.mValue = - ins->mSIntConst[0];
 				mIns.Push(bins);
 			}
 			else
 			{
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				lins.mRegisterFinal = ins.mSFinal[1];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				lins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(BC_BINOP_SUBR_16);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				bins.mRegisterFinal = ins.mSFinal[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				bins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(bins);
 			}
 			break;
@@ -2124,114 +2124,114 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns
 		{
 			ByteCode	bc = ByteCodeBinRegOperator(ins);
 			ByteCode	bci = ByteCodeBinImmOperator(ins);
-			if (ins.mSTemp[1] < 0)
+			if (ins->mSTemp[1] < 0)
 			{
-				if (ins.mSIntConst[1] >= 0 && ins.mSIntConst[1] <= 255)
+				if (ins->mSIntConst[1] >= 0 && ins->mSIntConst[1] <= 255)
 				{
-					if (ins.mSTemp[0] == ins.mTTemp)
+					if (ins->mSTemp[0] == ins->mTTemp)
 					{
 						ByteCodeInstruction	bins(bci);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-						bins.mRegisterFinal = ins.mSFinal[0];
-						bins.mValue = ins.mSIntConst[1];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+						bins.mRegisterFinal = ins->mSFinal[0];
+						bins.mValue = ins->mSIntConst[1];
 						mIns.Push(bins);
 						return;
 					}
 
 					ByteCodeInstruction	lins(BC_LOAD_REG_16);
-					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-					lins.mRegisterFinal = ins.mSFinal[0];
+					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+					lins.mRegisterFinal = ins->mSFinal[0];
 					mIns.Push(lins);
 
 					ByteCodeInstruction	bins(bci);
 					bins.mRegister = BC_REG_ACCU;
-					bins.mValue = ins.mSIntConst[1];
+					bins.mValue = ins->mSIntConst[1];
 					mIns.Push(bins);
 				}
 				else
 				{
-					IntConstToAccu(ins.mSIntConst[1]);
+					IntConstToAccu(ins->mSIntConst[1]);
 					ByteCodeInstruction	bins(bc);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-					bins.mRegisterFinal = ins.mSFinal[0];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+					bins.mRegisterFinal = ins->mSFinal[0];
 					mIns.Push(bins);
 				}
 			}
-			else if (ins.mSTemp[0] < 0)
+			else if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mSIntConst[0] >= 0 && ins.mSIntConst[0] <= 255)
+				if (ins->mSIntConst[0] >= 0 && ins->mSIntConst[0] <= 255)
 				{
-					if (ins.mSTemp[1] == ins.mTTemp)
+					if (ins->mSTemp[1] == ins->mTTemp)
 					{
 						ByteCodeInstruction	bins(bci);
-						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-						bins.mRegisterFinal = ins.mSFinal[1];
-						bins.mValue = ins.mSIntConst[0];
+						bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+						bins.mRegisterFinal = ins->mSFinal[1];
+						bins.mValue = ins->mSIntConst[0];
 						mIns.Push(bins);
 						return;
 					}
 
 					ByteCodeInstruction	lins(BC_LOAD_REG_16);
-					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-					lins.mRegisterFinal = ins.mSFinal[1];
+					lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+					lins.mRegisterFinal = ins->mSFinal[1];
 					mIns.Push(lins);
 
 					ByteCodeInstruction	bins(bci);
 					bins.mRegister = BC_REG_ACCU;
-					bins.mValue = ins.mSIntConst[0];
+					bins.mValue = ins->mSIntConst[0];
 					mIns.Push(bins);
 				}
 				else
 				{
-					IntConstToAccu(ins.mSIntConst[0]);
+					IntConstToAccu(ins->mSIntConst[0]);
 					ByteCodeInstruction	bins(bc);
-					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-					bins.mRegisterFinal = ins.mSFinal[1];
+					bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+					bins.mRegisterFinal = ins->mSFinal[1];
 					mIns.Push(bins);
 				}
 			}
 			else
 			{
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				lins.mRegisterFinal = ins.mSFinal[1];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				lins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(bc);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				bins.mRegisterFinal = ins.mSFinal[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				bins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(bins);
 			}
 		} break;
 		case IA_XOR:
 		{
 			ByteCode	bc = ByteCodeBinRegOperator(ins);
-			if (ins.mSTemp[1] < 0)
+			if (ins->mSTemp[1] < 0)
 			{
-				IntConstToAccu(ins.mSIntConst[1]);
+				IntConstToAccu(ins->mSIntConst[1]);
 				ByteCodeInstruction	bins(bc);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				bins.mRegisterFinal = ins.mSFinal[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				bins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(bins);
 			}
-			else if (ins.mSTemp[0] < 0)
+			else if (ins->mSTemp[0] < 0)
 			{
-				IntConstToAccu(ins.mSIntConst[0]);
+				IntConstToAccu(ins->mSIntConst[0]);
 				ByteCodeInstruction	bins(bc);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				bins.mRegisterFinal = ins.mSFinal[1];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				bins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(bins);
 			}
 			else
 			{
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				lins.mRegisterFinal = ins.mSFinal[1];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				lins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(bc);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				bins.mRegisterFinal = ins.mSFinal[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				bins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(bins);
 			}
 		} break;
@@ -2241,22 +2241,22 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns
 		case IA_MODU:
 		{
 			ByteCode	bc = ByteCodeBinRegOperator(ins);
-			if (ins.mSTemp[1] < 0)
+			if (ins->mSTemp[1] < 0)
 			{
-				IntConstToAccu(ins.mSIntConst[1]);
+				IntConstToAccu(ins->mSIntConst[1]);
 				ByteCodeInstruction	bins(bc);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				bins.mRegisterFinal = ins.mSFinal[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				bins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(bins);
 			}
-			else if (ins.mSTemp[0] < 0)
+			else if (ins->mSTemp[0] < 0)
 			{
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				lins.mRegisterFinal = ins.mSFinal[1];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				lins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(lins);
 
-				IntConstToAddr(ins.mSIntConst[0]);
+				IntConstToAddr(ins->mSIntConst[0]);
 
 				ByteCodeInstruction	bins(bc);
 				bins.mRegister = BC_REG_ADDR;
@@ -2265,13 +2265,13 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns
 			else
 			{
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				lins.mRegisterFinal = ins.mSFinal[1];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				lins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(bc);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				bins.mRegisterFinal = ins.mSFinal[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				bins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(bins);
 			}
 		} break;
@@ -2283,36 +2283,36 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns
 			ByteCode	rbc = ByteCodeBinRegOperator(ins);
 
 			ByteCode	ibc = ByteCodeBinImmOperator(ins);
-			if (ins.mSTemp[1] < 0)
+			if (ins->mSTemp[1] < 0)
 			{
-				IntConstToAccu(ins.mSIntConst[1]);
+				IntConstToAccu(ins->mSIntConst[1]);
 
 				ByteCodeInstruction	bins(rbc);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				bins.mRegisterFinal = ins.mSFinal[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				bins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(bins);
 			}
-			else if (ins.mSTemp[0] < 0)
+			else if (ins->mSTemp[0] < 0)
 			{
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				lins.mRegisterFinal = ins.mSFinal[1];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				lins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(ibc);
-				bins.mValue = ins.mSIntConst[0];
+				bins.mValue = ins->mSIntConst[0];
 				mIns.Push(bins);
 			}
 			else
 			{
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
-				lins.mRegisterFinal = ins.mSFinal[1];
+				lins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
+				lins.mRegisterFinal = ins->mSFinal[1];
 				mIns.Push(lins);
 
 				ByteCodeInstruction	bins(rbc);
-				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				bins.mRegisterFinal = ins.mSFinal[0];
+				bins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				bins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(bins);
 			}
 
@@ -2320,7 +2320,7 @@ void ByteCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterIns
 		}
 
 		ByteCodeInstruction	sins(BC_STORE_REG_16);
-		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+		sins.mRegister = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 		mIns.Push(sins);
 	}
 }
@@ -2332,9 +2332,9 @@ void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* p
 	int	i = 0;
 	while (i < sblock->mInstructions.Size())
 	{
-		const InterInstruction	& ins = sblock->mInstructions[i];
+		const InterInstruction	* ins = sblock->mInstructions[i];
 
-		switch (ins.mCode)
+		switch (ins->mCode)
 		{
 		case IC_STORE:
 			StoreDirectValue(iproc, ins);
@@ -2347,41 +2347,41 @@ void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* p
 			break;
 		case IC_LOAD_TEMPORARY:
 		{
-			if (ins.mSTemp[0] != ins.mTTemp)
+			if (ins->mSTemp[0] != ins->mTTemp)
 			{
-				switch (ins.mTType)
+				switch (ins->mTType)
 				{
 				case IT_BOOL:
 				case IT_INT8:
 				{
 					ByteCodeInstruction	lins(BC_LOAD_REG_8);
-					lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]];
-					lins.mRegisterFinal = ins.mSFinal[0];
+					lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]];
+					lins.mRegisterFinal = ins->mSFinal[0];
 					mIns.Push(lins);
 					ByteCodeInstruction	sins(BC_STORE_REG_8);
-					sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mTTemp];
+					sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mTTemp];
 					mIns.Push(sins);
 				} break;
 				case IT_INT16:
 				case IT_POINTER:
 				{
 					ByteCodeInstruction	lins(BC_LOAD_REG_16);
-					lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]];
-					lins.mRegisterFinal = ins.mSFinal[0];
+					lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]];
+					lins.mRegisterFinal = ins->mSFinal[0];
 					mIns.Push(lins);
 					ByteCodeInstruction	sins(BC_STORE_REG_16);
-					sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mTTemp];
+					sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mTTemp];
 					mIns.Push(sins);
 				} break;
 				case IT_INT32:
 				case IT_FLOAT:
 				{
 					ByteCodeInstruction	lins(BC_LOAD_REG_32);
-					lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]];
-					lins.mRegisterFinal = ins.mSFinal[0];
+					lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]];
+					lins.mRegisterFinal = ins->mSFinal[0];
 					mIns.Push(lins);
 					ByteCodeInstruction	sins(BC_STORE_REG_32);
-					sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mTTemp];
+					sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mTTemp];
 					mIns.Push(sins);
 				} break;
 
@@ -2412,20 +2412,20 @@ void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* p
 		case IC_PUSH_FRAME: 
 		{
 			ByteCodeInstruction	bins(BC_PUSH_FRAME);
-			bins.mValue = ins.mIntValue + 2;
+			bins.mValue = ins->mIntValue + 2;
 			mIns.Push(bins);
 
 		}	break;
 		case IC_POP_FRAME:
 		{
 			ByteCodeInstruction	bins(BC_POP_FRAME);
-			bins.mValue = ins.mIntValue + 2;
+			bins.mValue = ins->mIntValue + 2;
 			mIns.Push(bins);
 
 		}	break;
 
 		case IC_RELATIONAL_OPERATOR:
-			if (sblock->mInstructions[i + 1].mCode == IC_BRANCH)
+			if (sblock->mInstructions[i + 1]->mCode == IC_BRANCH)
 			{
 				ByteCode code = RelationalOperator(iproc, ins);
 				this->Close(proc->CompileBlock(iproc, sblock->mTrueJump), proc->CompileBlock(iproc, sblock->mFalseJump), code);
@@ -2437,27 +2437,27 @@ void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* p
 				ByteCode code = RelationalOperator(iproc, ins);
 				ByteCodeInstruction	bins(ByteCode(code - BC_BRANCHS_EQ + BC_SET_EQ));
 				mIns.Push(bins);
-				ByteCodeInstruction	sins(StoreTypedTmpCodes[ins.mTType]);
-				sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mTTemp];
+				ByteCodeInstruction	sins(StoreTypedTmpCodes[ins->mTType]);
+				sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mTTemp];
 				mIns.Push(sins);
 			}
 			break;
 
 		case IC_RETURN_VALUE:
-			if (ins.mSTemp[0] < 0)
-				IntConstToAccu(ins.mSIntConst[0]);
-			else if (ins.mSType[0] == IT_FLOAT)
+			if (ins->mSTemp[0] < 0)
+				IntConstToAccu(ins->mSIntConst[0]);
+			else if (ins->mSType[0] == IT_FLOAT)
 			{
 				ByteCodeInstruction	lins(BC_LOAD_REG_32);
-				lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]];
-				lins.mRegisterFinal = ins.mSFinal[0];
+				lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]];
+				lins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(lins);
 			}
 			else
 			{
-				ByteCodeInstruction	lins(InterTypeSize[ins.mSType[0]] == 1 ? BC_LOAD_REG_8 : BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]];
-				lins.mRegisterFinal = ins.mSFinal[0];
+				ByteCodeInstruction	lins(InterTypeSize[ins->mSType[0]] == 1 ? BC_LOAD_REG_8 : BC_LOAD_REG_16);
+				lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]];
+				lins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(lins);
 			}
 
@@ -2469,31 +2469,31 @@ void ByteCodeBasicBlock::Compile(InterCodeProcedure* iproc, ByteCodeProcedure* p
 			return;
 
 		case IC_TYPECAST:
-			if (ins.mSTemp[0] >= 0 && ins.mTTemp != ins.mSTemp[0])
+			if (ins->mSTemp[0] >= 0 && ins->mTTemp != ins->mSTemp[0])
 			{
 				ByteCodeInstruction	lins(BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]];
-				lins.mRegisterFinal = ins.mSFinal[0];
+				lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]];
+				lins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(lins);
 				ByteCodeInstruction	sins(BC_STORE_REG_16);
-				sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mTTemp];
+				sins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mTTemp];
 				mIns.Push(sins);
 			}
 			break;
 
 		case IC_BRANCH:
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mSIntConst[0] == 0)
+				if (ins->mSIntConst[0] == 0)
 					this->Close(proc->CompileBlock(iproc, sblock->mFalseJump), nullptr, BC_JUMPS);
 				else
 					this->Close(proc->CompileBlock(iproc, sblock->mTrueJump), nullptr, BC_JUMPS);
 			}
 			else
 			{
-				ByteCodeInstruction	lins(InterTypeSize[ins.mSType[0]] == 1 ? BC_LOAD_REG_8 : BC_LOAD_REG_16);
-				lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]];
-				lins.mRegisterFinal = ins.mSFinal[0];
+				ByteCodeInstruction	lins(InterTypeSize[ins->mSType[0]] == 1 ? BC_LOAD_REG_8 : BC_LOAD_REG_16);
+				lins.mRegister = BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]];
+				lins.mRegisterFinal = ins->mSFinal[0];
 				mIns.Push(lins);
 
 				this->Close(proc->CompileBlock(iproc, sblock->mTrueJump), proc->CompileBlock(iproc, sblock->mFalseJump), BC_BRANCHS_NE);
diff --git a/oscar64/ByteCodeGenerator.h b/oscar64/ByteCodeGenerator.h
index e3ee0a7a..69e42243 100644
--- a/oscar64/ByteCodeGenerator.h
+++ b/oscar64/ByteCodeGenerator.h
@@ -221,19 +221,19 @@ class ByteCodeBasicBlock
 	void IntConstToAddr(__int64 val);
 	void FloatConstToAccu(double val);
 	void FloatConstToWork(double val);
-	void CopyValue(InterCodeProcedure* proc, const InterInstruction& ins);
-	void LoadConstant(InterCodeProcedure* proc, const InterInstruction& ins);
-	void StoreDirectValue(InterCodeProcedure* proc, const InterInstruction & ins);
-	void LoadDirectValue(InterCodeProcedure* proc, const InterInstruction& ins);
-	void LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction& ins);
-	void CallFunction(InterCodeProcedure* proc, const InterInstruction& ins);
-	void CallAssembler(InterCodeProcedure* proc, const InterInstruction& ins);
-	void BinaryOperator(InterCodeProcedure* proc, const InterInstruction& ins);
-	void UnaryOperator(InterCodeProcedure* proc, const InterInstruction& ins);
-	void BinaryRROperator(InterCodeProcedure* proc, const InterInstruction& ins);
-	ByteCode RelationalOperator(InterCodeProcedure* proc, const InterInstruction& ins);
-	void BinaryIntOperator(InterCodeProcedure* proc, const InterInstruction& ins, ByteCode code);
-	void NumericConversion(InterCodeProcedure* proc, const InterInstruction& ins);
+	void CopyValue(InterCodeProcedure* proc, const InterInstruction * ins);
+	void LoadConstant(InterCodeProcedure* proc, const InterInstruction * ins);
+	void StoreDirectValue(InterCodeProcedure* proc, const InterInstruction * ins);
+	void LoadDirectValue(InterCodeProcedure* proc, const InterInstruction * ins);
+	void LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction * ins);
+	void CallFunction(InterCodeProcedure* proc, const InterInstruction * ins);
+	void CallAssembler(InterCodeProcedure* proc, const InterInstruction * ins);
+	void BinaryOperator(InterCodeProcedure* proc, const InterInstruction * ins);
+	void UnaryOperator(InterCodeProcedure* proc, const InterInstruction * ins);
+	void BinaryRROperator(InterCodeProcedure* proc, const InterInstruction * ins);
+	ByteCode RelationalOperator(InterCodeProcedure* proc, const InterInstruction * ins);
+	void BinaryIntOperator(InterCodeProcedure* proc, const InterInstruction * ins, ByteCode code);
+	void NumericConversion(InterCodeProcedure* proc, const InterInstruction * ins);
 
 	void PeepHoleOptimizer(void);
 };
diff --git a/oscar64/InterCode.cpp b/oscar64/InterCode.cpp
index e4410dfb..2d8c126f 100644
--- a/oscar64/InterCode.cpp
+++ b/oscar64/InterCode.cpp
@@ -236,34 +236,34 @@ static double ConstantFolding(InterOperator oper, double val1, double val2 = 0.0
 	}
 }
 
-static void ConversionConstantFold(InterInstruction& ins, InterInstruction * cins)
+static void ConversionConstantFold(InterInstruction * ins, InterInstruction * cins)
 {
-	switch (ins.mOperator)
+	switch (ins->mOperator)
 	{
 	case IA_INT2FLOAT:
-		ins.mCode = IC_CONSTANT;
-		ins.mFloatValue = (double)(cins->mIntValue);
-		ins.mSTemp[0] = -1;
+		ins->mCode = IC_CONSTANT;
+		ins->mFloatValue = (double)(cins->mIntValue);
+		ins->mSTemp[0] = -1;
 		break;
 	case IA_FLOAT2INT:
-		ins.mCode = IC_CONSTANT;
-		ins.mIntValue = (int)(cins->mFloatValue);
-		ins.mSTemp[0] = -1;
+		ins->mCode = IC_CONSTANT;
+		ins->mIntValue = (int)(cins->mFloatValue);
+		ins->mSTemp[0] = -1;
 		break;
 	case IA_EXT8TO16S:
-		ins.mCode = IC_CONSTANT;
-		ins.mIntValue = (char)(cins->mIntValue);
-		ins.mSTemp[0] = -1;
+		ins->mCode = IC_CONSTANT;
+		ins->mIntValue = (char)(cins->mIntValue);
+		ins->mSTemp[0] = -1;
 		break;
 	case IA_EXT8TO16U:
-		ins.mCode = IC_CONSTANT;
-		ins.mIntValue = (unsigned char)(cins->mIntValue);
-		ins.mSTemp[0] = -1;
+		ins->mCode = IC_CONSTANT;
+		ins->mIntValue = (unsigned char)(cins->mIntValue);
+		ins->mSTemp[0] = -1;
 		break;
 	}
 }
 
-void ValueSet::InsertValue(InterInstruction& ins)
+void ValueSet::InsertValue(InterInstruction * ins)
 {
 	InterInstructionPtr* nins;
 	int								i;
@@ -278,7 +278,7 @@ void ValueSet::InsertValue(InterInstruction& ins)
 		mInstructions = nins;
 	}
 
-	mInstructions[mNum++] = &ins;
+	mInstructions[mNum++] = ins;
 }
 
 static bool MemPtrRange(const InterInstruction* ins, const GrowingInstructionPtrArray& tvalue, InterMemory& mem, int& vindex, int& offset)
@@ -365,11 +365,11 @@ void ValueSet::Intersect(ValueSet& set)
 	mNum = k;
 }
 
-void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArray& tvalue, const NumberSet& aliasedLocals, const NumberSet& aliasedParams)
+void ValueSet::UpdateValue(InterInstruction * ins, const GrowingInstructionPtrArray& tvalue, const NumberSet& aliasedLocals, const NumberSet& aliasedParams)
 {
 	int	i, value, temp;
 
-	temp = ins.mTTemp;
+	temp = ins->mTTemp;
 
 	if (temp >= 0)
 	{
@@ -392,39 +392,39 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 
 	for (i = 0; i < 3; i++)
 	{
-		temp = ins.mSTemp[i];
+		temp = ins->mSTemp[i];
 		if (temp >= 0 && tvalue[temp])
 		{
-			ins.mSTemp[i] = tvalue[temp]->mTTemp;
+			ins->mSTemp[i] = tvalue[temp]->mTTemp;
 		}
 	}
 
-	switch (ins.mCode)
+	switch (ins->mCode)
 	{
 	case IC_LOAD:
 		i = 0;
 		while (i < mNum &&
 			(mInstructions[i]->mCode != IC_LOAD ||
-				mInstructions[i]->mSTemp[0] != ins.mSTemp[0] ||
-				mInstructions[i]->mOperandSize != ins.mOperandSize))
+				mInstructions[i]->mSTemp[0] != ins->mSTemp[0] ||
+				mInstructions[i]->mOperandSize != ins->mOperandSize))
 		{
 			i++;
 		}
 
 		if (i < mNum)
 		{
-			ins.mCode = IC_LOAD_TEMPORARY;
-			ins.mSTemp[0] = mInstructions[i]->mTTemp;
-			ins.mSType[0] = mInstructions[i]->mTType;
-			assert(ins.mSTemp[0] >= 0);
+			ins->mCode = IC_LOAD_TEMPORARY;
+			ins->mSTemp[0] = mInstructions[i]->mTTemp;
+			ins->mSType[0] = mInstructions[i]->mTType;
+			assert(ins->mSTemp[0] >= 0);
 		}
 		else
 		{
 			i = 0;
 			while (i < mNum &&
 				(mInstructions[i]->mCode != IC_STORE ||
-					mInstructions[i]->mSTemp[1] != ins.mSTemp[0] ||
-					mInstructions[i]->mOperandSize != ins.mOperandSize))
+					mInstructions[i]->mSTemp[1] != ins->mSTemp[0] ||
+					mInstructions[i]->mOperandSize != ins->mOperandSize))
 			{
 				i++;
 			}
@@ -433,17 +433,17 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 			{
 				if (mInstructions[i]->mSTemp[0] < 0)
 				{
-					ins.mCode = IC_CONSTANT;
-					ins.mSTemp[0] = -1;
-					ins.mSType[0] = mInstructions[i]->mSType[0];
-					ins.mIntValue = mInstructions[i]->mSIntConst[0];
+					ins->mCode = IC_CONSTANT;
+					ins->mSTemp[0] = -1;
+					ins->mSType[0] = mInstructions[i]->mSType[0];
+					ins->mIntValue = mInstructions[i]->mSIntConst[0];
 				}
 				else
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = mInstructions[i]->mSTemp[0];
-					ins.mSType[0] = mInstructions[i]->mSType[0];
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = mInstructions[i]->mSTemp[0];
+					ins->mSType[0] = mInstructions[i]->mSType[0];
+					assert(ins->mSTemp[0] >= 0);
 				}
 			}
 			else
@@ -457,7 +457,7 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		i = 0;
 		while (i < mNum)
 		{
-			if ((mInstructions[i]->mCode == IC_LOAD || mInstructions[i]->mCode == IC_STORE) && StoreAliasing(mInstructions[i], &ins, tvalue, aliasedLocals, aliasedParams))
+			if ((mInstructions[i]->mCode == IC_LOAD || mInstructions[i]->mCode == IC_STORE) && StoreAliasing(mInstructions[i], ins, tvalue, aliasedLocals, aliasedParams))
 			{
 				mNum--;
 				if (mNum > 0)
@@ -473,7 +473,7 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		i = 0;
 		while (i < mNum)
 		{
-			if ((mInstructions[i]->mCode == IC_LOAD || mInstructions[i]->mCode == IC_STORE) && StoreAliasing(mInstructions[i], &ins, tvalue, aliasedLocals, aliasedParams))
+			if ((mInstructions[i]->mCode == IC_LOAD || mInstructions[i]->mCode == IC_STORE) && StoreAliasing(mInstructions[i], ins, tvalue, aliasedLocals, aliasedParams))
 			{
 				mNum--;
 				if (mNum > 0)
@@ -486,14 +486,14 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		break;
 
 	case IC_CONSTANT:
-		switch (ins.mTType)
+		switch (ins->mTType)
 		{
 		case IT_FLOAT:
 			i = 0;
 			while (i < mNum &&
 				(mInstructions[i]->mCode != IC_CONSTANT ||
-					mInstructions[i]->mTType != ins.mTType ||
-					mInstructions[i]->mFloatValue != ins.mFloatValue))
+					mInstructions[i]->mTType != ins->mTType ||
+					mInstructions[i]->mFloatValue != ins->mFloatValue))
 			{
 				i++;
 			}
@@ -502,10 +502,10 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 			i = 0;
 			while (i < mNum &&
 				(mInstructions[i]->mCode != IC_CONSTANT ||
-					mInstructions[i]->mTType != ins.mTType ||
-					mInstructions[i]->mIntValue != ins.mIntValue ||
-					mInstructions[i]->mMemory != ins.mMemory ||
-					mInstructions[i]->mVarIndex != ins.mVarIndex))
+					mInstructions[i]->mTType != ins->mTType ||
+					mInstructions[i]->mIntValue != ins->mIntValue ||
+					mInstructions[i]->mMemory != ins->mMemory ||
+					mInstructions[i]->mVarIndex != ins->mVarIndex))
 			{
 				i++;
 			}
@@ -515,8 +515,8 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 			i = 0;
 			while (i < mNum &&
 				(mInstructions[i]->mCode != IC_CONSTANT ||
-					mInstructions[i]->mTType != ins.mTType ||
-					mInstructions[i]->mIntValue != ins.mIntValue))
+					mInstructions[i]->mTType != ins->mTType ||
+					mInstructions[i]->mIntValue != ins->mIntValue))
 			{
 				i++;
 			}
@@ -524,10 +524,10 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 
 		if (i < mNum)
 		{
-			ins.mCode = IC_LOAD_TEMPORARY;
-			ins.mSTemp[0] = mInstructions[i]->mTTemp;
-			ins.mSType[0] = mInstructions[i]->mTType;
-			assert(ins.mSTemp[0] >= 0);
+			ins->mCode = IC_LOAD_TEMPORARY;
+			ins->mSTemp[0] = mInstructions[i]->mTTemp;
+			ins->mSType[0] = mInstructions[i]->mTType;
+			assert(ins->mSTemp[0] >= 0);
 		}
 		else
 		{
@@ -539,20 +539,20 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		i = 0;
 		while (i < mNum &&
 			(mInstructions[i]->mCode != IC_LEA ||
-				mInstructions[i]->mSTemp[0] != ins.mSTemp[0] ||
-				mInstructions[i]->mSIntConst[0] != ins.mSIntConst[0] ||
-				mInstructions[i]->mSTemp[1] != ins.mSTemp[1]))
+				mInstructions[i]->mSTemp[0] != ins->mSTemp[0] ||
+				mInstructions[i]->mSIntConst[0] != ins->mSIntConst[0] ||
+				mInstructions[i]->mSTemp[1] != ins->mSTemp[1]))
 		{
 			i++;
 		}
 
 		if (i < mNum)
 		{
-			ins.mCode = IC_LOAD_TEMPORARY;
-			ins.mSTemp[0] = mInstructions[i]->mTTemp;
-			ins.mSType[0] = mInstructions[i]->mTType;
-			ins.mSTemp[1] = -1;
-			assert(ins.mSTemp[0] >= 0);
+			ins->mCode = IC_LOAD_TEMPORARY;
+			ins->mSTemp[0] = mInstructions[i]->mTTemp;
+			ins->mSType[0] = mInstructions[i]->mTType;
+			ins->mSTemp[1] = -1;
+			assert(ins->mSTemp[0] >= 0);
 		}
 		else
 		{
@@ -561,32 +561,32 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		break;
 
 	case IC_BINARY_OPERATOR:
-		switch (ins.mSType[0])
+		switch (ins->mSType[0])
 		{
 		case IT_FLOAT:
-			if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT &&
-				ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT &&
+				ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mFloatValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mFloatValue, tvalue[ins.mSTemp[0]]->mFloatValue);
-				ins.mSTemp[0] = -1;
-				ins.mSTemp[1] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mFloatValue = ConstantFolding(ins->mOperator, tvalue[ins->mSTemp[1]]->mFloatValue, tvalue[ins->mSTemp[0]]->mFloatValue);
+				ins->mSTemp[0] = -1;
+				ins->mSTemp[1] = -1;
 
 				i = 0;
 				while (i < mNum &&
 					(mInstructions[i]->mCode != IC_CONSTANT ||
-						mInstructions[i]->mTType != ins.mTType ||
-						mInstructions[i]->mFloatValue != ins.mFloatValue))
+						mInstructions[i]->mTType != ins->mTType ||
+						mInstructions[i]->mFloatValue != ins->mFloatValue))
 				{
 					i++;
 				}
 
 				if (i < mNum)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = mInstructions[i]->mTTemp;
-					ins.mSType[0] = mInstructions[i]->mTType;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = mInstructions[i]->mTTemp;
+					ins->mSType[0] = mInstructions[i]->mTType;
+					assert(ins->mSTemp[0] >= 0);
 				}
 				else
 				{
@@ -598,20 +598,20 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 				i = 0;
 				while (i < mNum &&
 					(mInstructions[i]->mCode != IC_BINARY_OPERATOR ||
-						mInstructions[i]->mOperator != ins.mOperator ||
-						mInstructions[i]->mSTemp[0] != ins.mSTemp[0] ||
-						mInstructions[i]->mSTemp[1] != ins.mSTemp[1]))
+						mInstructions[i]->mOperator != ins->mOperator ||
+						mInstructions[i]->mSTemp[0] != ins->mSTemp[0] ||
+						mInstructions[i]->mSTemp[1] != ins->mSTemp[1]))
 				{
 					i++;
 				}
 
 				if (i < mNum)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = mInstructions[i]->mTTemp;
-					ins.mSType[0] = mInstructions[i]->mTType;
-					ins.mSTemp[1] = -1;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = mInstructions[i]->mTTemp;
+					ins->mSType[0] = mInstructions[i]->mTType;
+					ins->mSTemp[1] = -1;
+					assert(ins->mSTemp[0] >= 0);
 				}
 				else
 				{
@@ -622,104 +622,104 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		case IT_POINTER:
 			break;
 		default:
-			if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT &&
-				ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT &&
+				ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mIntValue, tvalue[ins.mSTemp[0]]->mIntValue);
-				ins.mSTemp[0] = -1;
-				ins.mSTemp[1] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mIntValue = ConstantFolding(ins->mOperator, tvalue[ins->mSTemp[1]]->mIntValue, tvalue[ins->mSTemp[0]]->mIntValue);
+				ins->mSTemp[0] = -1;
+				ins->mSTemp[1] = -1;
 
 				UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 
 				return;
 			}
 
-			if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				if ((ins.mOperator == IA_ADD || ins.mOperator == IA_SUB ||
-					ins.mOperator == IA_OR || ins.mOperator == IA_XOR ||
-					ins.mOperator == IA_SHL || ins.mOperator == IA_SHR || ins.mOperator == IA_SAR) && tvalue[ins.mSTemp[0]]->mIntValue == 0 ||
-					(ins.mOperator == IA_MUL || ins.mOperator == IA_DIVU || ins.mOperator == IA_DIVS) && tvalue[ins.mSTemp[0]]->mIntValue == 1 ||
-					(ins.mOperator == IA_AND) && tvalue[ins.mSTemp[0]]->mIntValue == -1)
+				if ((ins->mOperator == IA_ADD || ins->mOperator == IA_SUB ||
+					ins->mOperator == IA_OR || ins->mOperator == IA_XOR ||
+					ins->mOperator == IA_SHL || ins->mOperator == IA_SHR || ins->mOperator == IA_SAR) && tvalue[ins->mSTemp[0]]->mIntValue == 0 ||
+					(ins->mOperator == IA_MUL || ins->mOperator == IA_DIVU || ins->mOperator == IA_DIVS) && tvalue[ins->mSTemp[0]]->mIntValue == 1 ||
+					(ins->mOperator == IA_AND) && tvalue[ins->mSTemp[0]]->mIntValue == -1)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = ins.mSTemp[1];
-					ins.mSType[0] = ins.mSType[1];
-					ins.mSTemp[1] = -1;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = ins->mSTemp[1];
+					ins->mSType[0] = ins->mSType[1];
+					ins->mSTemp[1] = -1;
+					assert(ins->mSTemp[0] >= 0);
 
 					UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 
 					return;
 				}
-				else if ((ins.mOperator == IA_MUL || ins.mOperator == IA_AND) && tvalue[ins.mSTemp[0]]->mIntValue == 0)
+				else if ((ins->mOperator == IA_MUL || ins->mOperator == IA_AND) && tvalue[ins->mSTemp[0]]->mIntValue == 0)
 				{
-					ins.mCode = IC_CONSTANT;
-					ins.mIntValue = 0;
-					ins.mSTemp[0] = -1;
-					ins.mSTemp[1] = -1;
+					ins->mCode = IC_CONSTANT;
+					ins->mIntValue = 0;
+					ins->mSTemp[0] = -1;
+					ins->mSTemp[1] = -1;
 
 					UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 
 					return;
 				}
 			}
-			else if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT)
+			else if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT)
 			{
-				if ((ins.mOperator == IA_ADD || ins.mOperator == IA_OR || ins.mOperator == IA_XOR) && tvalue[ins.mSTemp[1]]->mIntValue == 0 ||
-					(ins.mOperator == IA_MUL) && tvalue[ins.mSTemp[1]]->mIntValue == 1 ||
-					(ins.mOperator == IA_AND) && tvalue[ins.mSTemp[1]]->mIntValue == -1)
+				if ((ins->mOperator == IA_ADD || ins->mOperator == IA_OR || ins->mOperator == IA_XOR) && tvalue[ins->mSTemp[1]]->mIntValue == 0 ||
+					(ins->mOperator == IA_MUL) && tvalue[ins->mSTemp[1]]->mIntValue == 1 ||
+					(ins->mOperator == IA_AND) && tvalue[ins->mSTemp[1]]->mIntValue == -1)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[1] = -1;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[1] = -1;
+					assert(ins->mSTemp[0] >= 0);
 
 					UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 
 					return;
 				}
-				else if ((ins.mOperator == IA_MUL || ins.mOperator == IA_AND ||
-					ins.mOperator == IA_SHL || ins.mOperator == IA_SHR || ins.mOperator == IA_SAR) && tvalue[ins.mSTemp[1]]->mIntValue == 0)
+				else if ((ins->mOperator == IA_MUL || ins->mOperator == IA_AND ||
+					ins->mOperator == IA_SHL || ins->mOperator == IA_SHR || ins->mOperator == IA_SAR) && tvalue[ins->mSTemp[1]]->mIntValue == 0)
 				{
-					ins.mCode = IC_CONSTANT;
-					ins.mIntValue = 0;
-					ins.mSTemp[0] = -1;
-					ins.mSTemp[1] = -1;
+					ins->mCode = IC_CONSTANT;
+					ins->mIntValue = 0;
+					ins->mSTemp[0] = -1;
+					ins->mSTemp[1] = -1;
 
 					UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 
 					return;
 				}
-				else if (ins.mOperator == IA_SUB && tvalue[ins.mSTemp[1]]->mIntValue == 0)
+				else if (ins->mOperator == IA_SUB && tvalue[ins->mSTemp[1]]->mIntValue == 0)
 				{
-					ins.mCode = IC_UNARY_OPERATOR;
-					ins.mOperator = IA_NEG;
-					ins.mSTemp[1] = -1;
+					ins->mCode = IC_UNARY_OPERATOR;
+					ins->mOperator = IA_NEG;
+					ins->mSTemp[1] = -1;
 
 					UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 
 					return;
 				}
 			}
-			else if (ins.mSTemp[0] == ins.mSTemp[1])
+			else if (ins->mSTemp[0] == ins->mSTemp[1])
 			{
-				if (ins.mOperator == IA_SUB || ins.mOperator == IA_XOR)
+				if (ins->mOperator == IA_SUB || ins->mOperator == IA_XOR)
 				{
-					ins.mCode = IC_CONSTANT;
-					ins.mIntValue = 0;
-					ins.mSTemp[0] = -1;
-					ins.mSTemp[1] = -1;
+					ins->mCode = IC_CONSTANT;
+					ins->mIntValue = 0;
+					ins->mSTemp[0] = -1;
+					ins->mSTemp[1] = -1;
 
 					UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 
 					return;
 				}
-				else if (ins.mOperator == IA_AND || ins.mOperator == IA_OR)
+				else if (ins->mOperator == IA_AND || ins->mOperator == IA_OR)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[1] = -1;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[1] = -1;
+					assert(ins->mSTemp[0] >= 0);
 
 					UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 
@@ -730,20 +730,20 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 			i = 0;
 			while (i < mNum &&
 				(mInstructions[i]->mCode != IC_BINARY_OPERATOR ||
-					mInstructions[i]->mOperator != ins.mOperator ||
-					mInstructions[i]->mSTemp[0] != ins.mSTemp[0] ||
-					mInstructions[i]->mSTemp[1] != ins.mSTemp[1]))
+					mInstructions[i]->mOperator != ins->mOperator ||
+					mInstructions[i]->mSTemp[0] != ins->mSTemp[0] ||
+					mInstructions[i]->mSTemp[1] != ins->mSTemp[1]))
 			{
 				i++;
 			}
 
 			if (i < mNum)
 			{
-				ins.mCode = IC_LOAD_TEMPORARY;
-				ins.mSTemp[0] = mInstructions[i]->mTTemp;
-				ins.mSType[0] = mInstructions[i]->mTType;
-				ins.mSTemp[1] = -1;
-				assert(ins.mSTemp[0] >= 0);
+				ins->mCode = IC_LOAD_TEMPORARY;
+				ins->mSTemp[0] = mInstructions[i]->mTTemp;
+				ins->mSType[0] = mInstructions[i]->mTType;
+				ins->mSTemp[1] = -1;
+				assert(ins->mSTemp[0] >= 0);
 			}
 			else
 			{
@@ -754,26 +754,26 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		break;
 
 	case IC_CONVERSION_OPERATOR:
-		if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+		if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 		{
-			ConversionConstantFold(ins, tvalue[ins.mSTemp[0]]);
-			if (ins.mTType == IT_FLOAT)
+			ConversionConstantFold(ins, tvalue[ins->mSTemp[0]]);
+			if (ins->mTType == IT_FLOAT)
 			{
 				i = 0;
 				while (i < mNum &&
 					(mInstructions[i]->mCode != IC_CONSTANT ||
-						mInstructions[i]->mTType != ins.mTType ||
-						mInstructions[i]->mFloatValue != ins.mFloatValue))
+						mInstructions[i]->mTType != ins->mTType ||
+						mInstructions[i]->mFloatValue != ins->mFloatValue))
 				{
 					i++;
 				}
 
 				if (i < mNum)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = mInstructions[i]->mTTemp;
-					ins.mSType[0] = mInstructions[i]->mTType;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = mInstructions[i]->mTTemp;
+					ins->mSType[0] = mInstructions[i]->mTType;
+					assert(ins->mSTemp[0] >= 0);
 				}
 				else
 				{
@@ -790,19 +790,19 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 			i = 0;
 			while (i < mNum &&
 				(mInstructions[i]->mCode != IC_CONVERSION_OPERATOR ||
-					mInstructions[i]->mOperator != ins.mOperator ||
-					mInstructions[i]->mSTemp[0] != ins.mSTemp[0]))
+					mInstructions[i]->mOperator != ins->mOperator ||
+					mInstructions[i]->mSTemp[0] != ins->mSTemp[0]))
 			{
 				i++;
 			}
 
 			if (i < mNum)
 			{
-				ins.mCode = IC_LOAD_TEMPORARY;
-				ins.mSTemp[0] = mInstructions[i]->mTTemp;
-				ins.mSType[0] = mInstructions[i]->mTType;
-				ins.mSTemp[1] = -1;
-				assert(ins.mSTemp[0] >= 0);
+				ins->mCode = IC_LOAD_TEMPORARY;
+				ins->mSTemp[0] = mInstructions[i]->mTTemp;
+				ins->mSType[0] = mInstructions[i]->mTType;
+				ins->mSTemp[1] = -1;
+				assert(ins->mSTemp[0] >= 0);
 			}
 			else
 			{
@@ -812,30 +812,30 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		break;
 
 	case IC_UNARY_OPERATOR:
-		switch (ins.mSType[0])
+		switch (ins->mSType[0])
 		{
 		case IT_FLOAT:
-			if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mFloatValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[0]]->mFloatValue);
-				ins.mSTemp[0] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mFloatValue = ConstantFolding(ins->mOperator, tvalue[ins->mSTemp[0]]->mFloatValue);
+				ins->mSTemp[0] = -1;
 
 				i = 0;
 				while (i < mNum &&
 					(mInstructions[i]->mCode != IC_CONSTANT ||
-						mInstructions[i]->mTType != ins.mTType ||
-						mInstructions[i]->mFloatValue != ins.mFloatValue))
+						mInstructions[i]->mTType != ins->mTType ||
+						mInstructions[i]->mFloatValue != ins->mFloatValue))
 				{
 					i++;
 				}
 
 				if (i < mNum)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = mInstructions[i]->mTTemp;
-					ins.mSType[0] = mInstructions[i]->mTType;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = mInstructions[i]->mTTemp;
+					ins->mSType[0] = mInstructions[i]->mTType;
+					assert(ins->mSTemp[0] >= 0);
 				}
 				else
 				{
@@ -847,19 +847,19 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 				i = 0;
 				while (i < mNum &&
 					(mInstructions[i]->mCode != IC_UNARY_OPERATOR ||
-						mInstructions[i]->mOperator != ins.mOperator ||
-						mInstructions[i]->mSTemp[0] != ins.mSTemp[0]))
+						mInstructions[i]->mOperator != ins->mOperator ||
+						mInstructions[i]->mSTemp[0] != ins->mSTemp[0]))
 				{
 					i++;
 				}
 
 				if (i < mNum)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = mInstructions[i]->mTTemp;
-					ins.mSType[0] = mInstructions[i]->mTType;
-					ins.mSTemp[1] = -1;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = mInstructions[i]->mTTemp;
+					ins->mSType[0] = mInstructions[i]->mTType;
+					ins->mSTemp[1] = -1;
+					assert(ins->mSTemp[0] >= 0);
 				}
 				else
 				{
@@ -870,27 +870,27 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		case IT_POINTER:
 			break;
 		default:
-			if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[0]]->mIntValue);
-				ins.mSTemp[0] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mIntValue = ConstantFolding(ins->mOperator, tvalue[ins->mSTemp[0]]->mIntValue);
+				ins->mSTemp[0] = -1;
 
 				i = 0;
 				while (i < mNum &&
 					(mInstructions[i]->mCode != IC_CONSTANT ||
-						mInstructions[i]->mTType != ins.mTType ||
-						mInstructions[i]->mIntValue != ins.mIntValue))
+						mInstructions[i]->mTType != ins->mTType ||
+						mInstructions[i]->mIntValue != ins->mIntValue))
 				{
 					i++;
 				}
 
 				if (i < mNum)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = mInstructions[i]->mTTemp;
-					ins.mSType[0] = mInstructions[i]->mTType;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = mInstructions[i]->mTTemp;
+					ins->mSType[0] = mInstructions[i]->mTType;
+					assert(ins->mSTemp[0] >= 0);
 				}
 				else
 				{
@@ -902,18 +902,18 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 				i = 0;
 				while (i < mNum &&
 					(mInstructions[i]->mCode != IC_UNARY_OPERATOR ||
-						mInstructions[i]->mOperator != ins.mOperator ||
-						mInstructions[i]->mSTemp[0] != ins.mSTemp[0]))
+						mInstructions[i]->mOperator != ins->mOperator ||
+						mInstructions[i]->mSTemp[0] != ins->mSTemp[0]))
 				{
 					i++;
 				}
 
 				if (i < mNum)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = mInstructions[i]->mTTemp;
-					ins.mSType[0] = mInstructions[i]->mTType;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = mInstructions[i]->mTTemp;
+					ins->mSType[0] = mInstructions[i]->mTType;
+					assert(ins->mSTemp[0] >= 0);
 				}
 				else
 				{
@@ -925,16 +925,16 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		break;
 
 	case IC_RELATIONAL_OPERATOR:
-		switch (ins.mSType[1])
+		switch (ins->mSType[1])
 		{
 		case IT_FLOAT:
-			if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT &&
-				ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT &&
+				ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mIntValue = ConstantRelationalFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mFloatValue, tvalue[ins.mSTemp[0]]->mFloatValue);
-				ins.mSTemp[0] = -1;
-				ins.mSTemp[1] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mIntValue = ConstantRelationalFolding(ins->mOperator, tvalue[ins->mSTemp[1]]->mFloatValue, tvalue[ins->mSTemp[0]]->mFloatValue);
+				ins->mSTemp[0] = -1;
+				ins->mSTemp[1] = -1;
 
 				UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 			}
@@ -942,39 +942,39 @@ void ValueSet::UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArr
 		case IT_POINTER:
 			break;
 		default:
-			if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT &&
-				ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT &&
+				ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mIntValue, tvalue[ins.mSTemp[0]]->mIntValue);
-				ins.mSTemp[0] = -1;
-				ins.mSTemp[1] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mIntValue = ConstantFolding(ins->mOperator, tvalue[ins->mSTemp[1]]->mIntValue, tvalue[ins->mSTemp[0]]->mIntValue);
+				ins->mSTemp[0] = -1;
+				ins->mSTemp[1] = -1;
 
 				UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 			}
-			else if (ins.mSTemp[1] == ins.mSTemp[0])
+			else if (ins->mSTemp[1] == ins->mSTemp[0])
 			{
-				ins.mCode = IC_CONSTANT;
+				ins->mCode = IC_CONSTANT;
 
-				switch (ins.mOperator)
+				switch (ins->mOperator)
 				{
 				case IA_CMPEQ:
 				case IA_CMPGES:
 				case IA_CMPLES:
 				case IA_CMPGEU:
 				case IA_CMPLEU:
-					ins.mIntValue = 1;
+					ins->mIntValue = 1;
 					break;
 				case IA_CMPNE:
 				case IA_CMPGS:
 				case IA_CMPLS:
 				case IA_CMPGU:
 				case IA_CMPLU:
-					ins.mIntValue = 0;
+					ins->mIntValue = 0;
 					break;
 				}
-				ins.mSTemp[0] = -1;
-				ins.mSTemp[1] = -1;
+				ins->mSTemp[0] = -1;
+				ins->mSTemp[1] = -1;
 
 				UpdateValue(ins, tvalue, aliasedLocals, aliasedParams);
 			}
@@ -1017,6 +1017,7 @@ InterInstruction::InterInstruction(void)
 	mSTemp[2] = INVALID_TEMPORARY;
 
 	mSFinal[0] = mSFinal[1] = mSFinal[2] = false;
+	mInUse = false;
 }
 
 void InterInstruction::SetCode(const Location& loc, InterCode code)
@@ -1631,16 +1632,16 @@ void InterInstruction::Disassemble(FILE* file)
 		if (mSTemp[1] >= 0) 
 			fprintf(file, "R%d(%c%c), ", mSTemp[1], typechars[mSType[1]], mSFinal[1] ? 'F' : '-');
 		else if (this->mCode == IC_STORE)
-			fprintf(file, "V%d+%d, ", mVarIndex, mSIntConst[1]);
+			fprintf(file, "V%d+%d, ", mVarIndex, int(mSIntConst[1]));
 		if (mSTemp[0] >= 0)
 			fprintf(file, "R%d(%c%c)", mSTemp[0], typechars[mSType[0]], mSFinal[0] ? 'F' : '-');
 		else if (this->mCode == IC_LOAD)
-			fprintf(file, "V%d+%d", mVarIndex, mSIntConst[0]);
+			fprintf(file, "V%d+%d", mVarIndex, int(mSIntConst[0]));
 		if (this->mCode == IC_CONSTANT)
 		{
 			if (mTType == IT_POINTER)
 			{
-				fprintf(file, "C%c%d(%d:%d)", memchars[mMemory], mOperandSize, mVarIndex, mIntValue);
+				fprintf(file, "C%c%d(%d:%d)", memchars[mMemory], mOperandSize, mVarIndex, int(mIntValue));
 			}
 			else if (mTType == IT_FLOAT)
 				fprintf(file, "C%f", mFloatValue);
@@ -1653,7 +1654,7 @@ void InterInstruction::Disassemble(FILE* file)
 }
 
 InterCodeBasicBlock::InterCodeBasicBlock(void)
-	: mInstructions(InterInstruction()), mEntryRenameTable(-1), mExitRenameTable(-1), mMergeTValues(nullptr)
+	: mInstructions(nullptr), mEntryRenameTable(-1), mExitRenameTable(-1), mMergeTValues(nullptr)
 {
 	mInPath = false;
 	mLoopHead = false;
@@ -1664,8 +1665,10 @@ InterCodeBasicBlock::~InterCodeBasicBlock(void)
 }
 
 
-void InterCodeBasicBlock::Append(InterInstruction & code)
+void InterCodeBasicBlock::Append(InterInstruction * code)
 {
+	assert(!(code->mInUse));
+	code->mInUse = true;
 	this->mInstructions.Push(code);
 }
 
@@ -1703,14 +1706,14 @@ void InterCodeBasicBlock::GenerateTraces(void)
 
 		for (;;)
 		{
-			if (mTrueJump && mTrueJump->mInstructions.Size() == 1 && mTrueJump->mInstructions[0].mCode == IC_JUMP)
+			if (mTrueJump && mTrueJump->mInstructions.Size() == 1 && mTrueJump->mInstructions[0]->mCode == IC_JUMP)
 			{
 				mTrueJump->mNumEntries--;
 				mTrueJump = mTrueJump->mTrueJump;
 				if (mTrueJump)
 					mTrueJump->mNumEntries++;
 			}
-			else if (mFalseJump && mFalseJump->mInstructions.Size() == 1 && mFalseJump->mInstructions[0].mCode == IC_JUMP)
+			else if (mFalseJump && mFalseJump->mInstructions.Size() == 1 && mFalseJump->mInstructions[0]->mCode == IC_JUMP)
 			{
 				mFalseJump->mNumEntries--;
 				mFalseJump = mFalseJump->mTrueJump;
@@ -1723,7 +1726,7 @@ void InterCodeBasicBlock::GenerateTraces(void)
 
 				mInstructions.Pop();
 				for (i = 0; i < mTrueJump->mInstructions.Size(); i++)
-					mInstructions.Push(mTrueJump->mInstructions[i]);
+					mInstructions.Push(new InterInstruction(* (mTrueJump->mInstructions[i]) ));
 
 				mFalseJump = mTrueJump->mFalseJump;
 				mTrueJump = mTrueJump->mTrueJump;
@@ -1765,68 +1768,68 @@ static bool IsSimpleAddressMultiply(int val)
 	return false;
 }
 
-static void OptimizeAddress(InterInstruction& ins, const GrowingInstructionPtrArray& tvalue, int offset)
+static void OptimizeAddress(InterInstruction * ins, const GrowingInstructionPtrArray& tvalue, int offset)
 {
-	ins.mSIntConst[offset] = 0;
+	ins->mSIntConst[offset] = 0;
 
-	if (ins.mSTemp[offset] >= 0 && tvalue[ins.mSTemp[offset]])
+	if (ins->mSTemp[offset] >= 0 && tvalue[ins->mSTemp[offset]])
 	{
-		InterInstruction* ains = tvalue[ins.mSTemp[offset]];
+		InterInstruction* ains = tvalue[ins->mSTemp[offset]];
 
 		if (ains->mCode == IC_CONSTANT)
 		{
-			ins.mSIntConst[offset] = ains->mIntValue;
-			ins.mVarIndex = ains->mVarIndex;
-			ins.mMemory = ains->mMemory;
-			ins.mSTemp[offset] = -1;
+			ins->mSIntConst[offset] = ains->mIntValue;
+			ins->mVarIndex = ains->mVarIndex;
+			ins->mMemory = ains->mMemory;
+			ins->mSTemp[offset] = -1;
 		}
 		else if (ains->mCode == IC_LEA && ains->mSTemp[0] < 0 && ains->mSTemp[1] >= 0 && tvalue[ains->mSTemp[1]])
 		{
-			ins.mSIntConst[offset] = ains->mSIntConst[0];
-			ins.mSTemp[offset] = ains->mSTemp[1];
+			ins->mSIntConst[offset] = ains->mSIntConst[0];
+			ins->mSTemp[offset] = ains->mSTemp[1];
 		}
 	}
 }
 
 
-void InterCodeBasicBlock::CheckValueUsage(InterInstruction& ins, const GrowingInstructionPtrArray& tvalue)
+void InterCodeBasicBlock::CheckValueUsage(InterInstruction * ins, const GrowingInstructionPtrArray& tvalue)
 {
-	switch (ins.mCode)
+	switch (ins->mCode)
 	{
 	case IC_CALL:
 	case IC_JSR:
-		if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+		if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 		{
-			ins.mMemory = tvalue[ins.mSTemp[0]]->mMemory;
-			ins.mVarIndex = tvalue[ins.mSTemp[0]]->mVarIndex;
-			ins.mOperandSize = tvalue[ins.mSTemp[0]]->mOperandSize;
-			ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue;
-			ins.mSTemp[0] = -1;
+			ins->mMemory = tvalue[ins->mSTemp[0]]->mMemory;
+			ins->mVarIndex = tvalue[ins->mSTemp[0]]->mVarIndex;
+			ins->mOperandSize = tvalue[ins->mSTemp[0]]->mOperandSize;
+			ins->mSIntConst[0] = tvalue[ins->mSTemp[0]]->mIntValue;
+			ins->mSTemp[0] = -1;
 		}
 
 		break;
 	case IC_LOAD_TEMPORARY:
-		if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+		if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 		{
-			switch (ins.mSType[0])
+			switch (ins->mSType[0])
 			{
 			case IT_FLOAT:
-				ins.mCode = IC_CONSTANT;
-				ins.mFloatValue = tvalue[ins.mSTemp[0]]->mFloatValue;
-				ins.mSTemp[0] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mFloatValue = tvalue[ins->mSTemp[0]]->mFloatValue;
+				ins->mSTemp[0] = -1;
 				break;
 			case IT_POINTER:
-				ins.mCode = IC_CONSTANT;
-				ins.mMemory = tvalue[ins.mSTemp[0]]->mMemory;
-				ins.mVarIndex = tvalue[ins.mSTemp[0]]->mVarIndex;
-				ins.mIntValue = tvalue[ins.mSTemp[0]]->mIntValue;
-				ins.mOperandSize = tvalue[ins.mSTemp[0]]->mOperandSize;
-				ins.mSTemp[0] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mMemory = tvalue[ins->mSTemp[0]]->mMemory;
+				ins->mVarIndex = tvalue[ins->mSTemp[0]]->mVarIndex;
+				ins->mIntValue = tvalue[ins->mSTemp[0]]->mIntValue;
+				ins->mOperandSize = tvalue[ins->mSTemp[0]]->mOperandSize;
+				ins->mSTemp[0] = -1;
 				break;
 			default:
-				ins.mCode = IC_CONSTANT;
-				ins.mIntValue = tvalue[ins.mSTemp[0]]->mIntValue;
-				ins.mSTemp[0] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mIntValue = tvalue[ins->mSTemp[0]]->mIntValue;
+				ins->mSTemp[0] = -1;
 				break;
 			}
 		}
@@ -1836,167 +1839,167 @@ void InterCodeBasicBlock::CheckValueUsage(InterInstruction& ins, const GrowingIn
 		OptimizeAddress(ins, tvalue, 0);
 		break;
 	case IC_STORE:
-		if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+		if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 		{
-			switch (ins.mSType[0])
+			switch (ins->mSType[0])
 			{
 			case IT_FLOAT:
-				ins.mSFloatConst[0] = tvalue[ins.mSTemp[0]]->mFloatValue;
-				ins.mSTemp[0] = -1;
+				ins->mSFloatConst[0] = tvalue[ins->mSTemp[0]]->mFloatValue;
+				ins->mSTemp[0] = -1;
 				break;
 			case IT_POINTER:
 				break;
 			default:
-				ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue;
-				ins.mSTemp[0] = -1;
+				ins->mSIntConst[0] = tvalue[ins->mSTemp[0]]->mIntValue;
+				ins->mSTemp[0] = -1;
 				break;
 			}
 		}
 		OptimizeAddress(ins, tvalue, 1);
 		break;
 	case IC_LEA:
-		if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+		if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 		{
-			if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mTType = IT_POINTER;
-				ins.mMemory = tvalue[ins.mSTemp[1]]->mMemory;
-				ins.mVarIndex = tvalue[ins.mSTemp[1]]->mVarIndex;
-				ins.mIntValue = tvalue[ins.mSTemp[1]]->mIntValue + tvalue[ins.mSTemp[0]]->mIntValue;
-				ins.mOperandSize = tvalue[ins.mSTemp[1]]->mOperandSize;
-				ins.mSTemp[0] = -1;
-				ins.mSTemp[1] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mTType = IT_POINTER;
+				ins->mMemory = tvalue[ins->mSTemp[1]]->mMemory;
+				ins->mVarIndex = tvalue[ins->mSTemp[1]]->mVarIndex;
+				ins->mIntValue = tvalue[ins->mSTemp[1]]->mIntValue + tvalue[ins->mSTemp[0]]->mIntValue;
+				ins->mOperandSize = tvalue[ins->mSTemp[1]]->mOperandSize;
+				ins->mSTemp[0] = -1;
+				ins->mSTemp[1] = -1;
 			}
-			else if (tvalue[ins.mSTemp[0]]->mIntValue == 0)
+			else if (tvalue[ins->mSTemp[0]]->mIntValue == 0)
 			{
-				ins.mCode = IC_LOAD_TEMPORARY;
-				ins.mSType[0] = ins.mSType[1];
-				ins.mSTemp[0] = ins.mSTemp[1];
-				ins.mSTemp[1] = -1;
-				assert(ins.mSTemp[0] >= 0);
+				ins->mCode = IC_LOAD_TEMPORARY;
+				ins->mSType[0] = ins->mSType[1];
+				ins->mSTemp[0] = ins->mSTemp[1];
+				ins->mSTemp[1] = -1;
+				assert(ins->mSTemp[0] >= 0);
 			}
 			else
 			{
-				ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue;
-				ins.mSTemp[0] = -1;
+				ins->mSIntConst[0] = tvalue[ins->mSTemp[0]]->mIntValue;
+				ins->mSTemp[0] = -1;
 			}
 		}
 		break;
 	case IC_TYPECAST:
-		if (ins.mSType[0] == ins.mTType)
+		if (ins->mSType[0] == ins->mTType)
 		{
-			ins.mCode = IC_LOAD_TEMPORARY;
-			assert(ins.mSTemp[0] >= 0);
+			ins->mCode = IC_LOAD_TEMPORARY;
+			assert(ins->mSTemp[0] >= 0);
 		}
-		else if (TypeInteger(ins.mSType[0]) && ins.mTType == IT_POINTER)
+		else if (TypeInteger(ins->mSType[0]) && ins->mTType == IT_POINTER)
 		{
-			if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mTType = IT_POINTER;
-				ins.mMemory = IM_ABSOLUTE;
-				ins.mVarIndex = 0;
-				ins.mIntValue = tvalue[ins.mSTemp[0]]->mIntValue;
-				ins.mSTemp[0] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mTType = IT_POINTER;
+				ins->mMemory = IM_ABSOLUTE;
+				ins->mVarIndex = 0;
+				ins->mIntValue = tvalue[ins->mSTemp[0]]->mIntValue;
+				ins->mSTemp[0] = -1;
 			}
 		}
 		break;
 	case IC_RETURN_VALUE:
-		if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+		if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 		{
-			switch (ins.mSType[0])
+			switch (ins->mSType[0])
 			{
 			case IT_FLOAT:
 				break;
 			case IT_POINTER:
 				break;
 			default:
-				ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue;
-				ins.mSTemp[0] = -1;
+				ins->mSIntConst[0] = tvalue[ins->mSTemp[0]]->mIntValue;
+				ins->mSTemp[0] = -1;
 				break;
 			}
 		}
 		break;
 	case IC_BINARY_OPERATOR:
-		switch (ins.mSType[0])
+		switch (ins->mSType[0])
 		{
 		case IT_FLOAT:
-			if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT)
 			{
-				if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+				if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 				{
-					ins.mCode = IC_CONSTANT;
-					ins.mFloatValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mFloatValue, tvalue[ins.mSTemp[0]]->mFloatValue);
-					ins.mSTemp[0] = -1;
-					ins.mSTemp[1] = -1;
+					ins->mCode = IC_CONSTANT;
+					ins->mFloatValue = ConstantFolding(ins->mOperator, tvalue[ins->mSTemp[1]]->mFloatValue, tvalue[ins->mSTemp[0]]->mFloatValue);
+					ins->mSTemp[0] = -1;
+					ins->mSTemp[1] = -1;
 				}
 				else
 				{
-					ins.mSFloatConst[1] = tvalue[ins.mSTemp[1]]->mFloatValue;
-					ins.mSTemp[1] = -1;
+					ins->mSFloatConst[1] = tvalue[ins->mSTemp[1]]->mFloatValue;
+					ins->mSTemp[1] = -1;
 
-					if (ins.mOperator == IA_ADD && ins.mSFloatConst[1] == 0)
+					if (ins->mOperator == IA_ADD && ins->mSFloatConst[1] == 0)
 					{
-						ins.mCode = IC_LOAD_TEMPORARY;
-						assert(ins.mSTemp[0] >= 0);
+						ins->mCode = IC_LOAD_TEMPORARY;
+						assert(ins->mSTemp[0] >= 0);
 					}
-					else if (ins.mOperator == IA_MUL)
+					else if (ins->mOperator == IA_MUL)
 					{
-						if (ins.mSFloatConst[1] == 1.0)
+						if (ins->mSFloatConst[1] == 1.0)
 						{
-							ins.mCode = IC_LOAD_TEMPORARY;
-							assert(ins.mSTemp[0] >= 0);
+							ins->mCode = IC_LOAD_TEMPORARY;
+							assert(ins->mSTemp[0] >= 0);
 						}
-						else if (ins.mSFloatConst[1] == 0.0)
+						else if (ins->mSFloatConst[1] == 0.0)
 						{
-							ins.mCode = IC_CONSTANT;
-							ins.mFloatValue = 0.0;
-							ins.mSTemp[0] = -1;
-							ins.mSTemp[1] = -1;
+							ins->mCode = IC_CONSTANT;
+							ins->mFloatValue = 0.0;
+							ins->mSTemp[0] = -1;
+							ins->mSTemp[1] = -1;
 						}
-						else if (ins.mSFloatConst[1] == 2.0)
+						else if (ins->mSFloatConst[1] == 2.0)
 						{
-							ins.mOperator = IA_ADD;
-							ins.mSTemp[1] = ins.mSTemp[0];
-							assert(ins.mSTemp[0] >= 0);
+							ins->mOperator = IA_ADD;
+							ins->mSTemp[1] = ins->mSTemp[0];
+							assert(ins->mSTemp[0] >= 0);
 						}
 					}
 				}
 			}
-			else if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			else if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mSFloatConst[0] = tvalue[ins.mSTemp[0]]->mFloatValue;
-				ins.mSTemp[0] = -1;
+				ins->mSFloatConst[0] = tvalue[ins->mSTemp[0]]->mFloatValue;
+				ins->mSTemp[0] = -1;
 
-				if (ins.mOperator == IA_ADD && ins.mSFloatConst[0] == 0)
+				if (ins->mOperator == IA_ADD && ins->mSFloatConst[0] == 0)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = ins.mSTemp[1];
-					ins.mSTemp[1] = -1;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = ins->mSTemp[1];
+					ins->mSTemp[1] = -1;
+					assert(ins->mSTemp[0] >= 0);
 				}
-				else if (ins.mOperator == IA_MUL)
+				else if (ins->mOperator == IA_MUL)
 				{
-					if (ins.mSFloatConst[0] == 1.0)
+					if (ins->mSFloatConst[0] == 1.0)
 					{
-						ins.mCode = IC_LOAD_TEMPORARY;
-						ins.mSTemp[0] = ins.mSTemp[1];
-						ins.mSTemp[1] = -1;
-						assert(ins.mSTemp[0] >= 0);
+						ins->mCode = IC_LOAD_TEMPORARY;
+						ins->mSTemp[0] = ins->mSTemp[1];
+						ins->mSTemp[1] = -1;
+						assert(ins->mSTemp[0] >= 0);
 					}
-					else if (ins.mSFloatConst[0] == 0.0)
+					else if (ins->mSFloatConst[0] == 0.0)
 					{
-						ins.mCode = IC_CONSTANT;
-						ins.mFloatValue = 0.0;
-						ins.mSTemp[0] = -1;
-						ins.mSTemp[1] = -1;
+						ins->mCode = IC_CONSTANT;
+						ins->mFloatValue = 0.0;
+						ins->mSTemp[0] = -1;
+						ins->mSTemp[1] = -1;
 					}
-					else if (ins.mSFloatConst[0] == 2.0)
+					else if (ins->mSFloatConst[0] == 2.0)
 					{
-						ins.mOperator = IA_ADD;
-						ins.mSTemp[0] = ins.mSTemp[1];
-						assert(ins.mSTemp[0] >= 0);
+						ins->mOperator = IA_ADD;
+						ins->mSTemp[0] = ins->mSTemp[1];
+						assert(ins->mSTemp[0] >= 0);
 					}
 				}
 			}
@@ -2004,138 +2007,138 @@ void InterCodeBasicBlock::CheckValueUsage(InterInstruction& ins, const GrowingIn
 		case IT_POINTER:
 			break;
 		default:
-			if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT)
 			{
-				if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+				if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 				{
-					ins.mCode = IC_CONSTANT;
-					ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mIntValue, tvalue[ins.mSTemp[0]]->mIntValue);
-					ins.mSTemp[0] = -1;
-					ins.mSTemp[1] = -1;
+					ins->mCode = IC_CONSTANT;
+					ins->mIntValue = ConstantFolding(ins->mOperator, tvalue[ins->mSTemp[1]]->mIntValue, tvalue[ins->mSTemp[0]]->mIntValue);
+					ins->mSTemp[0] = -1;
+					ins->mSTemp[1] = -1;
 				}
 				else
 				{
-					ins.mSIntConst[1] = tvalue[ins.mSTemp[1]]->mIntValue;
-					ins.mSTemp[1] = -1;
+					ins->mSIntConst[1] = tvalue[ins->mSTemp[1]]->mIntValue;
+					ins->mSTemp[1] = -1;
 #if 1
-					if (ins.mOperator == IA_ADD && ins.mSIntConst[1] == 0)
+					if (ins->mOperator == IA_ADD && ins->mSIntConst[1] == 0)
 					{
-						ins.mCode = IC_LOAD_TEMPORARY;
-						assert(ins.mSTemp[0] >= 0);
+						ins->mCode = IC_LOAD_TEMPORARY;
+						assert(ins->mSTemp[0] >= 0);
 					}
-					else if (ins.mOperator == IA_MUL)
+					else if (ins->mOperator == IA_MUL)
 					{
-						if (ins.mSIntConst[1] == 1)
+						if (ins->mSIntConst[1] == 1)
 						{
-							ins.mCode = IC_LOAD_TEMPORARY;
-							assert(ins.mSTemp[0] >= 0);
+							ins->mCode = IC_LOAD_TEMPORARY;
+							assert(ins->mSTemp[0] >= 0);
 						}
-						else if (ins.mSIntConst[1] == 2)
+						else if (ins->mSIntConst[1] == 2)
 						{
-							ins.mOperator = IA_SHL;
-							ins.mSTemp[1] = ins.mSTemp[0];
-							ins.mSType[1] = ins.mSType[0];
-							ins.mSTemp[0] = -1;
-							ins.mSIntConst[0] = 1;
+							ins->mOperator = IA_SHL;
+							ins->mSTemp[1] = ins->mSTemp[0];
+							ins->mSType[1] = ins->mSType[0];
+							ins->mSTemp[0] = -1;
+							ins->mSIntConst[0] = 1;
 						}
-						else if (ins.mSIntConst[1] == 4)
+						else if (ins->mSIntConst[1] == 4)
 						{
-							ins.mOperator = IA_SHL;
-							ins.mSTemp[1] = ins.mSTemp[0];
-							ins.mSType[1] = ins.mSType[0];
-							ins.mSTemp[0] = -1;
-							ins.mSIntConst[0] = 2;
+							ins->mOperator = IA_SHL;
+							ins->mSTemp[1] = ins->mSTemp[0];
+							ins->mSType[1] = ins->mSType[0];
+							ins->mSTemp[0] = -1;
+							ins->mSIntConst[0] = 2;
 						}
-						else if (ins.mSIntConst[1] == 8)
+						else if (ins->mSIntConst[1] == 8)
 						{
-							ins.mOperator = IA_SHL;
-							ins.mSTemp[1] = ins.mSTemp[0];
-							ins.mSType[1] = ins.mSType[0];
-							ins.mSTemp[0] = -1;
-							ins.mSIntConst[0] = 3;
+							ins->mOperator = IA_SHL;
+							ins->mSTemp[1] = ins->mSTemp[0];
+							ins->mSType[1] = ins->mSType[0];
+							ins->mSTemp[0] = -1;
+							ins->mSIntConst[0] = 3;
 						}
 
 					}
 #endif
 				}
 			}
-			else if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			else if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue;
-				ins.mSTemp[0] = -1;
+				ins->mSIntConst[0] = tvalue[ins->mSTemp[0]]->mIntValue;
+				ins->mSTemp[0] = -1;
 
-				if (ins.mOperator == IA_ADD && ins.mSIntConst[0] == 0)
+				if (ins->mOperator == IA_ADD && ins->mSIntConst[0] == 0)
 				{
-					ins.mCode = IC_LOAD_TEMPORARY;
-					ins.mSTemp[0] = ins.mSTemp[1];
-					ins.mSTemp[1] = -1;
-					assert(ins.mSTemp[0] >= 0);
+					ins->mCode = IC_LOAD_TEMPORARY;
+					ins->mSTemp[0] = ins->mSTemp[1];
+					ins->mSTemp[1] = -1;
+					assert(ins->mSTemp[0] >= 0);
 				}
-				else if (ins.mOperator == IA_MUL)
+				else if (ins->mOperator == IA_MUL)
 				{
-					if (ins.mSIntConst[0] == 1)
+					if (ins->mSIntConst[0] == 1)
 					{
-						ins.mCode = IC_LOAD_TEMPORARY;
-						ins.mSTemp[0] = ins.mSTemp[1];
-						ins.mSTemp[1] = -1;
-						assert(ins.mSTemp[0] >= 0);
+						ins->mCode = IC_LOAD_TEMPORARY;
+						ins->mSTemp[0] = ins->mSTemp[1];
+						ins->mSTemp[1] = -1;
+						assert(ins->mSTemp[0] >= 0);
 					}
-					else if (ins.mSIntConst[0] == 2)
+					else if (ins->mSIntConst[0] == 2)
 					{
-						ins.mOperator = IA_SHL;
-						ins.mSIntConst[0] = 1;
+						ins->mOperator = IA_SHL;
+						ins->mSIntConst[0] = 1;
 					}
-					else if (ins.mSIntConst[0] == 4)
+					else if (ins->mSIntConst[0] == 4)
 					{
-						ins.mOperator = IA_SHL;
-						ins.mSIntConst[0] = 2;
+						ins->mOperator = IA_SHL;
+						ins->mSIntConst[0] = 2;
 					}
-					else if (ins.mSIntConst[0] == 8)
+					else if (ins->mSIntConst[0] == 8)
 					{
-						ins.mOperator = IA_SHL;
-						ins.mSIntConst[0] = 3;
+						ins->mOperator = IA_SHL;
+						ins->mSIntConst[0] = 3;
 					}
 				}
 			}
 
-			if (ins.mSTemp[1] < 0 && ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_BINARY_OPERATOR)
+			if (ins->mSTemp[1] < 0 && ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_BINARY_OPERATOR)
 			{
-				InterInstruction* pins = tvalue[ins.mSTemp[0]];
-				if (ins.mOperator == pins->mOperator && (ins.mOperator == IA_ADD || ins.mOperator == IA_MUL || ins.mOperator == IA_AND || ins.mOperator == IA_OR))
+				InterInstruction* pins = tvalue[ins->mSTemp[0]];
+				if (ins->mOperator == pins->mOperator && (ins->mOperator == IA_ADD || ins->mOperator == IA_MUL || ins->mOperator == IA_AND || ins->mOperator == IA_OR))
 				{
 					if (pins->mSTemp[1] < 0)
 					{
-						ins.mSIntConst[1] = ConstantFolding(ins.mOperator, ins.mSIntConst[1], pins->mSIntConst[1]);
-						ins.mSTemp[0] = pins->mSTemp[0];
+						ins->mSIntConst[1] = ConstantFolding(ins->mOperator, ins->mSIntConst[1], pins->mSIntConst[1]);
+						ins->mSTemp[0] = pins->mSTemp[0];
 					}
 					else if (pins->mSTemp[0] < 0)
 					{
-						ins.mSIntConst[1] = ConstantFolding(ins.mOperator, ins.mSIntConst[1], pins->mSIntConst[0]);
-						ins.mSTemp[0] = pins->mSTemp[1];
+						ins->mSIntConst[1] = ConstantFolding(ins->mOperator, ins->mSIntConst[1], pins->mSIntConst[0]);
+						ins->mSTemp[0] = pins->mSTemp[1];
 					}
 				}
 			}
-			else if (ins.mSTemp[0] < 0 && ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_BINARY_OPERATOR)
+			else if (ins->mSTemp[0] < 0 && ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_BINARY_OPERATOR)
 			{
-				InterInstruction* pins = tvalue[ins.mSTemp[1]];
-				if (ins.mOperator == pins->mOperator && (ins.mOperator == IA_ADD || ins.mOperator == IA_MUL || ins.mOperator == IA_AND || ins.mOperator == IA_OR))
+				InterInstruction* pins = tvalue[ins->mSTemp[1]];
+				if (ins->mOperator == pins->mOperator && (ins->mOperator == IA_ADD || ins->mOperator == IA_MUL || ins->mOperator == IA_AND || ins->mOperator == IA_OR))
 				{
 					if (pins->mSTemp[1] < 0)
 					{
-						ins.mSIntConst[0] = ConstantFolding(ins.mOperator, ins.mSIntConst[0], pins->mSIntConst[1]);
-						ins.mSTemp[1] = pins->mSTemp[0];
+						ins->mSIntConst[0] = ConstantFolding(ins->mOperator, ins->mSIntConst[0], pins->mSIntConst[1]);
+						ins->mSTemp[1] = pins->mSTemp[0];
 					}
 					else if (pins->mSTemp[0] < 0)
 					{
-						ins.mSIntConst[0] = ConstantFolding(ins.mOperator, ins.mSIntConst[0], pins->mSIntConst[0]);
-						ins.mSTemp[1] = pins->mSTemp[1];
+						ins->mSIntConst[0] = ConstantFolding(ins->mOperator, ins->mSIntConst[0], pins->mSIntConst[0]);
+						ins->mSTemp[1] = pins->mSTemp[1];
 					}
 				}
-				else if (ins.mOperator == IA_SHL && (pins->mOperator == IA_SHR || pins->mOperator == IA_SAR) && pins->mSTemp[0] < 0 && ins.mSIntConst[0] == pins->mSIntConst[0])
+				else if (ins->mOperator == IA_SHL && (pins->mOperator == IA_SHR || pins->mOperator == IA_SAR) && pins->mSTemp[0] < 0 && ins->mSIntConst[0] == pins->mSIntConst[0])
 				{
-					ins.mOperator = IA_AND;
-					ins.mSIntConst[0] = -1LL << ins.mSIntConst[0];
-					ins.mSTemp[1] = pins->mSTemp[1];
+					ins->mOperator = IA_AND;
+					ins->mSIntConst[0] = -1LL << ins->mSIntConst[0];
+					ins->mSTemp[1] = pins->mSTemp[1];
 				}
 			}
 
@@ -2143,14 +2146,14 @@ void InterCodeBasicBlock::CheckValueUsage(InterInstruction& ins, const GrowingIn
 		}
 		break;
 	case IC_UNARY_OPERATOR:
-		switch (ins.mSType[0])
+		switch (ins->mSType[0])
 		{
 		case IT_FLOAT:
-			if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mFloatValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[0]]->mFloatValue);
-				ins.mSTemp[0] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mFloatValue = ConstantFolding(ins->mOperator, tvalue[ins->mSTemp[0]]->mFloatValue);
+				ins->mSTemp[0] = -1;
 			}
 			break;
 		case IT_POINTER:
@@ -2160,77 +2163,77 @@ void InterCodeBasicBlock::CheckValueUsage(InterInstruction& ins, const GrowingIn
 		}
 		break;
 	case IC_RELATIONAL_OPERATOR:
-		switch (ins.mSType[1])
+		switch (ins->mSType[1])
 		{
 		case IT_FLOAT:
-			if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT &&
-				ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT &&
+				ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mIntValue = ConstantRelationalFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mFloatValue, tvalue[ins.mSTemp[0]]->mFloatValue);
-				ins.mTType = IT_BOOL;
-				ins.mSTemp[0] = -1;
-				ins.mSTemp[1] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mIntValue = ConstantRelationalFolding(ins->mOperator, tvalue[ins->mSTemp[1]]->mFloatValue, tvalue[ins->mSTemp[0]]->mFloatValue);
+				ins->mTType = IT_BOOL;
+				ins->mSTemp[0] = -1;
+				ins->mSTemp[1] = -1;
 			}
 			else
 			{
-				if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT)
+				if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT)
 				{
-					ins.mSFloatConst[1] = tvalue[ins.mSTemp[1]]->mFloatValue;
-					ins.mSTemp[1] = -1;
+					ins->mSFloatConst[1] = tvalue[ins->mSTemp[1]]->mFloatValue;
+					ins->mSTemp[1] = -1;
 				}
-				else if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+				else if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 				{
-					ins.mSFloatConst[0] = tvalue[ins.mSTemp[0]]->mFloatValue;
-					ins.mSTemp[0] = -1;
+					ins->mSFloatConst[0] = tvalue[ins->mSTemp[0]]->mFloatValue;
+					ins->mSTemp[0] = -1;
 				}
 			}
 			break;
 		case IT_POINTER:
-			if (ins.mOperator == IA_CMPEQ || ins.mOperator == IA_CMPNE)
+			if (ins->mOperator == IA_CMPEQ || ins->mOperator == IA_CMPNE)
 			{
-				if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+				if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 				{
-					ins.mOperandSize = tvalue[ins.mSTemp[0]]->mOperandSize;
-					ins.mSTemp[0] = -1;
+					ins->mOperandSize = tvalue[ins->mSTemp[0]]->mOperandSize;
+					ins->mSTemp[0] = -1;
 				}
-				else if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT)
+				else if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT)
 				{
-					ins.mOperandSize = tvalue[ins.mSTemp[1]]->mOperandSize;
-					ins.mSTemp[1] = -1;
+					ins->mOperandSize = tvalue[ins->mSTemp[1]]->mOperandSize;
+					ins->mSTemp[1] = -1;
 				}
 			}
 			break;
 		default:
-			if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT &&
-				ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+			if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT &&
+				ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 			{
-				ins.mCode = IC_CONSTANT;
-				ins.mIntValue = ConstantFolding(ins.mOperator, tvalue[ins.mSTemp[1]]->mIntValue, tvalue[ins.mSTemp[0]]->mIntValue);
-				ins.mSTemp[0] = -1;
-				ins.mSTemp[1] = -1;
+				ins->mCode = IC_CONSTANT;
+				ins->mIntValue = ConstantFolding(ins->mOperator, tvalue[ins->mSTemp[1]]->mIntValue, tvalue[ins->mSTemp[0]]->mIntValue);
+				ins->mSTemp[0] = -1;
+				ins->mSTemp[1] = -1;
 			}
 			else
 			{
-				if (ins.mSTemp[1] >= 0 && tvalue[ins.mSTemp[1]] && tvalue[ins.mSTemp[1]]->mCode == IC_CONSTANT)
+				if (ins->mSTemp[1] >= 0 && tvalue[ins->mSTemp[1]] && tvalue[ins->mSTemp[1]]->mCode == IC_CONSTANT)
 				{
-					ins.mSIntConst[1] = tvalue[ins.mSTemp[1]]->mIntValue;
-					ins.mSTemp[1] = -1;
+					ins->mSIntConst[1] = tvalue[ins->mSTemp[1]]->mIntValue;
+					ins->mSTemp[1] = -1;
 				}
-				else if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+				else if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 				{
-					ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue;
-					ins.mSTemp[0] = -1;
+					ins->mSIntConst[0] = tvalue[ins->mSTemp[0]]->mIntValue;
+					ins->mSTemp[0] = -1;
 				}
 			}
 			break;
 		}
 		break;
 	case IC_BRANCH:
-		if (ins.mSTemp[0] >= 0 && tvalue[ins.mSTemp[0]] && tvalue[ins.mSTemp[0]]->mCode == IC_CONSTANT)
+		if (ins->mSTemp[0] >= 0 && tvalue[ins->mSTemp[0]] && tvalue[ins->mSTemp[0]]->mCode == IC_CONSTANT)
 		{
-			ins.mSIntConst[0] = tvalue[ins.mSTemp[0]]->mIntValue;
-			ins.mSTemp[0] = -1;
+			ins->mSIntConst[0] = tvalue[ins->mSTemp[0]]->mIntValue;
+			ins->mSTemp[0] = -1;
 		}
 		break;
 	}
@@ -2246,7 +2249,7 @@ void InterCodeBasicBlock::CollectLocalAddressTemps(GrowingIntArray& localTable,
 		mVisited = true;
 
 		for (i = 0; i < mInstructions.Size(); i++)
-			mInstructions[i].CollectLocalAddressTemps(localTable, paramTable);
+			mInstructions[i]->CollectLocalAddressTemps(localTable, paramTable);
 
 		if (mTrueJump) mTrueJump->CollectLocalAddressTemps(localTable, paramTable);
 		if (mFalseJump) mFalseJump->CollectLocalAddressTemps(localTable, paramTable);
@@ -2262,7 +2265,7 @@ void InterCodeBasicBlock::MarkAliasedLocalTemps(const GrowingIntArray& localTabl
 		mVisited = true;
 
 		for (i = 0; i < mInstructions.Size(); i++)
-			mInstructions[i].MarkAliasedLocalTemps(localTable, aliasedLocals, paramTable, aliasedParams);
+			mInstructions[i]->MarkAliasedLocalTemps(localTable, aliasedLocals, paramTable, aliasedParams);
 
 		if (mTrueJump) mTrueJump->MarkAliasedLocalTemps(localTable, aliasedLocals, paramTable, aliasedParams);
 		if (mFalseJump) mFalseJump->MarkAliasedLocalTemps(localTable, aliasedLocals, paramTable, aliasedParams);
@@ -2279,7 +2282,7 @@ void  InterCodeBasicBlock::CollectConstTemps(GrowingInstructionPtrArray& ctemps,
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			int		ttemp = mInstructions[i].mTTemp;
+			int		ttemp = mInstructions[i]->mTTemp;
 			if (ttemp >= 0)
 			{
 				if (assignedTemps[ttemp])
@@ -2287,8 +2290,8 @@ void  InterCodeBasicBlock::CollectConstTemps(GrowingInstructionPtrArray& ctemps,
 				else
 				{
 					assignedTemps += ttemp;
-					if (mInstructions[i].mCode == IC_CONSTANT)
-						ctemps[ttemp] = &(mInstructions[i]);
+					if (mInstructions[i]->mCode == IC_CONSTANT)
+						ctemps[ttemp] = mInstructions[i];
 				}
 			}
 		}
@@ -2310,7 +2313,7 @@ bool InterCodeBasicBlock::PropagateConstTemps(const GrowingInstructionPtrArray&
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			if (mInstructions[i].PropagateConstTemps(ctemps))
+			if (mInstructions[i]->PropagateConstTemps(ctemps))
 				changed = true;
 		}
 
@@ -2341,7 +2344,7 @@ void InterCodeBasicBlock::BuildLocalTempSets(int num, int numFixed)
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			mInstructions[i].FilterTempUsage(mLocalRequiredTemps, mLocalProvidedTemps);
+			mInstructions[i]->FilterTempUsage(mLocalRequiredTemps, mLocalProvidedTemps);
 		}
 
 		mEntryRequiredTemps = mLocalRequiredTemps;
@@ -2411,7 +2414,7 @@ void InterCodeBasicBlock::PerformTempForwarding(TempForwardingTable& forwardingT
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			mInstructions[i].PerformTempForwarding(localForwardingTable);
+			mInstructions[i]->PerformTempForwarding(localForwardingTable);
 		}
 
 		if (mTrueJump) mTrueJump->PerformTempForwarding(localForwardingTable);
@@ -2465,10 +2468,10 @@ bool InterCodeBasicBlock::RemoveUnusedResultInstructions(int numStaticTemps)
 
 		for (i = mInstructions.Size() - 1; i > 0; i--)
 		{
-			if (mInstructions[i].RemoveUnusedResultInstructions(&(mInstructions[i - 1]), requiredTemps, numStaticTemps))
+			if (mInstructions[i]->RemoveUnusedResultInstructions(mInstructions[i - 1], requiredTemps, numStaticTemps))
 				changed = true;
 		}
-		if (mInstructions[0].RemoveUnusedResultInstructions(NULL, requiredTemps, numStaticTemps))
+		if (mInstructions[0]->RemoveUnusedResultInstructions(NULL, requiredTemps, numStaticTemps))
 			changed = true;
 
 		if (mTrueJump)
@@ -2496,7 +2499,7 @@ void InterCodeBasicBlock::BuildCallerSaveTempSet(NumberSet& callerSaveTemps)
 		int i;
 
 		for (i = mInstructions.Size() - 1; i >= 0; i--)
-			mInstructions[i].BuildCallerSaveTempSet(requiredTemps, callerSaveTemps);
+			mInstructions[i]->BuildCallerSaveTempSet(requiredTemps, callerSaveTemps);
 	
 		if (mTrueJump)
 			mTrueJump->BuildCallerSaveTempSet(callerSaveTemps);
@@ -2524,7 +2527,7 @@ void InterCodeBasicBlock::BuildLocalVariableSets(const GrowingVariableArray& loc
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			mInstructions[i].FilterVarsUsage(localVars, mLocalRequiredVars, mLocalProvidedVars);
+			mInstructions[i]->FilterVarsUsage(localVars, mLocalRequiredVars, mLocalProvidedVars);
 		}
 
 		mEntryRequiredVars = mLocalRequiredVars;
@@ -2592,7 +2595,7 @@ bool InterCodeBasicBlock::RemoveUnusedStoreInstructions(const GrowingVariableArr
 
 		for (i = mInstructions.Size() - 1; i >= 0; i--)
 		{
-			if (mInstructions[i].RemoveUnusedStoreInstructions(localVars, requiredVars))
+			if (mInstructions[i]->RemoveUnusedStoreInstructions(localVars, requiredVars))
 				changed = true;
 		}
 
@@ -2667,7 +2670,7 @@ void InterCodeBasicBlock::PerformValueForwarding(const GrowingInstructionPtrArra
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
 			lvalues.UpdateValue(mInstructions[i], ltvalue, aliasedLocals, aliasedParams);
-			mInstructions[i].PerformValueForwarding(ltvalue, tvalid);
+			mInstructions[i]->PerformValueForwarding(ltvalue, tvalid);
 		}
 
 		if (mTrueJump) mTrueJump->PerformValueForwarding(ltvalue, lvalues, tvalid, aliasedLocals, aliasedParams);
@@ -2701,7 +2704,7 @@ void InterCodeBasicBlock::PerformMachineSpecificValueUsageCheck(const GrowingIns
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
 			CheckValueUsage(mInstructions[i], ltvalue);
-			mInstructions[i].PerformValueForwarding(ltvalue, tvalid);
+			mInstructions[i]->PerformValueForwarding(ltvalue, tvalid);
 		}
 
 		if (mTrueJump) mTrueJump->PerformMachineSpecificValueUsageCheck(ltvalue, tvalid);
@@ -2773,7 +2776,7 @@ void InterCodeBasicBlock::LocalRenameRegister(const GrowingIntArray& renameTable
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			mInstructions[i].LocalRenameRegister(mExitRenameTable, num, fixed);
+			mInstructions[i]->LocalRenameRegister(mExitRenameTable, num, fixed);
 		}
 
 		if (mTrueJump) mTrueJump->LocalRenameRegister(mExitRenameTable, num, fixed);
@@ -2812,7 +2815,7 @@ void InterCodeBasicBlock::GlobalRenameRegister(const GrowingIntArray& renameTabl
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			mInstructions[i].GlobalRenameRegister(renameTable, temporaries);
+			mInstructions[i]->GlobalRenameRegister(renameTable, temporaries);
 		}
 
 		if (mTrueJump) mTrueJump->GlobalRenameRegister(renameTable, temporaries);
@@ -2845,7 +2848,7 @@ void InterCodeBasicBlock::BuildCollisionTable(NumberSet* collisionSets)
 
 		for (i = mInstructions.Size() - 1; i >= 0; i--)
 		{
-			mInstructions[i].BuildCollisionTable(requiredTemps, collisionSets);
+			mInstructions[i]->BuildCollisionTable(requiredTemps, collisionSets);
 		}
 
 		if (mTrueJump) mTrueJump->BuildCollisionTable(collisionSets);
@@ -2863,7 +2866,7 @@ void InterCodeBasicBlock::ReduceTemporaries(const GrowingIntArray& renameTable,
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			mInstructions[i].ReduceTemporaries(renameTable, temporaries);
+			mInstructions[i]->ReduceTemporaries(renameTable, temporaries);
 		}
 
 		if (mTrueJump) mTrueJump->ReduceTemporaries(renameTable, temporaries);
@@ -2909,22 +2912,22 @@ void InterCodeBasicBlock::MapVariables(GrowingVariableArray& globalVars, Growing
 		{
 			bool	found = false;
 
-			switch (mInstructions[i].mCode)
+			switch (mInstructions[i]->mCode)
 			{
 			case IC_CONSTANT:
-				if (mInstructions[i].mTType != IT_POINTER)
+				if (mInstructions[i]->mTType != IT_POINTER)
 					break;
 
 			case IC_STORE:
 			case IC_LOAD:
 			case IC_JSR:
-				if (mInstructions[i].mMemory == IM_GLOBAL)
+				if (mInstructions[i]->mMemory == IM_GLOBAL)
 				{
-					UseGlobal(globalVars, mInstructions[i].mVarIndex);
+					UseGlobal(globalVars, mInstructions[i]->mVarIndex);
 				}
-				else if (mInstructions[i].mMemory == IM_LOCAL)
+				else if (mInstructions[i]->mMemory == IM_LOCAL)
 				{
-					localVars[mInstructions[i].mVarIndex].mUsed = true;
+					localVars[mInstructions[i]->mVarIndex].mUsed = true;
 				}
 				break;
 			}
@@ -2945,21 +2948,21 @@ void InterCodeBasicBlock::CollectOuterFrame(int level, int& size)
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			if (mInstructions[i].mCode == IC_PUSH_FRAME)
+			if (mInstructions[i]->mCode == IC_PUSH_FRAME)
 			{
 				level++;
 				if (level == 1)
 				{
-					if (mInstructions[i].mIntValue > size)
-						size = mInstructions[i].mIntValue;
-					mInstructions[i].mCode = IC_NONE;
+					if (mInstructions[i]->mIntValue > size)
+						size = mInstructions[i]->mIntValue;
+					mInstructions[i]->mCode = IC_NONE;
 				}
 			}
-			else if (mInstructions[i].mCode == IC_POP_FRAME)
+			else if (mInstructions[i]->mCode == IC_POP_FRAME)
 			{
 				if (level == 1)
 				{
-					mInstructions[i].mCode = IC_NONE;
+					mInstructions[i]->mCode = IC_NONE;
 				}
 				level--;
 			}
@@ -2979,7 +2982,7 @@ bool InterCodeBasicBlock::IsLeafProcedure(void)
 		mVisited = true;
 
 		for (i = 0; i < mInstructions.Size(); i++)
-			if (mInstructions[i].mCode == IC_CALL || mInstructions[i].mCode == IC_JSR)
+			if (mInstructions[i]->mCode == IC_CALL || mInstructions[i]->mCode == IC_JSR)
 				return false;
 
 		if (mTrueJump && !mTrueJump->IsLeafProcedure())
@@ -2991,42 +2994,42 @@ bool InterCodeBasicBlock::IsLeafProcedure(void)
 	return true;
 }
 
-static bool CanBypassLoad(const InterInstruction& lins, const InterInstruction& bins)
+static bool CanBypassLoad(const InterInstruction * lins, const InterInstruction * bins)
 {
 	// Check ambiguity
-	if (bins.mCode == IC_STORE || bins.mCode == IC_COPY)
+	if (bins->mCode == IC_STORE || bins->mCode == IC_COPY)
 		return false;
 
 	// Side effects
-	if (bins.mCode == IC_CALL || bins.mCode == IC_JSR)
+	if (bins->mCode == IC_CALL || bins->mCode == IC_JSR)
 		return false;
 
 	// True data dependency
-	if (lins.mTTemp == bins.mSTemp[0] || lins.mTTemp == bins.mSTemp[1] || lins.mTTemp == bins.mSTemp[2])
+	if (lins->mTTemp == bins->mSTemp[0] || lins->mTTemp == bins->mSTemp[1] || lins->mTTemp == bins->mSTemp[2])
 		return false;
 
 	// False data dependency
-	if (lins.mSTemp[0] >= 0 && lins.mSTemp[0] == bins.mTTemp)
+	if (lins->mSTemp[0] >= 0 && lins->mSTemp[0] == bins->mTTemp)
 		return false;
 
 	return true;
 }
 
-static bool CanBypassStore(const InterInstruction& sins, const InterInstruction& bins)
+static bool CanBypassStore(const InterInstruction * sins, const InterInstruction * bins)
 {
-	if (bins.mCode == IC_COPY || bins.mCode == IC_PUSH_FRAME)
+	if (bins->mCode == IC_COPY || bins->mCode == IC_PUSH_FRAME)
 		return false;
 
 	// Check ambiguity
-	if (bins.mCode == IC_STORE || bins.mCode == IC_LOAD)
+	if (bins->mCode == IC_STORE || bins->mCode == IC_LOAD)
 	{
-		if (sins.mMemory == IM_LOCAL)
+		if (sins->mMemory == IM_LOCAL)
 		{
-			if (bins.mMemory == IM_PARAM || bins.mMemory == IM_GLOBAL)
+			if (bins->mMemory == IM_PARAM || bins->mMemory == IM_GLOBAL)
 				;
-			else if (bins.mMemory == IM_LOCAL)
+			else if (bins->mMemory == IM_LOCAL)
 			{
-				if (bins.mVarIndex == sins.mVarIndex)
+				if (bins->mVarIndex == sins->mVarIndex)
 					return false;
 			}
 			else
@@ -3036,15 +3039,15 @@ static bool CanBypassStore(const InterInstruction& sins, const InterInstruction&
 			return false;
 	}
 
-	if (sins.mMemory == IM_FRAME && (bins.mCode == IC_PUSH_FRAME || bins.mCode == IC_POP_FRAME))
+	if (sins->mMemory == IM_FRAME && (bins->mCode == IC_PUSH_FRAME || bins->mCode == IC_POP_FRAME))
 		return false;
 
 	// Side effects
-	if (bins.mCode == IC_CALL || bins.mCode == IC_JSR)
+	if (bins->mCode == IC_CALL || bins->mCode == IC_JSR)
 		return false;
 
 	// True data dependency
-	if (bins.mTTemp >= 0 && (bins.mTTemp == sins.mSTemp[0] || bins.mTTemp == sins.mSTemp[1]))
+	if (bins->mTTemp >= 0 && (bins->mTTemp == sins->mSTemp[0] || bins->mTTemp == sins->mSTemp[1]))
 		return false;
 
 	return true;
@@ -3065,9 +3068,9 @@ void InterCodeBasicBlock::PeepholeOptimization(void)
 		while (i >= 0)
 		{
 			// move loads down
-			if (mInstructions[i].mCode == IC_LOAD)
+			if (mInstructions[i]->mCode == IC_LOAD)
 			{
-				InterInstruction	ins(mInstructions[i]);
+				InterInstruction	*	ins(mInstructions[i]);
 				int j = i;
 				while (j + 2 < mInstructions.Size() && CanBypassLoad(ins, mInstructions[j + 1]))
 				{
@@ -3085,9 +3088,9 @@ void InterCodeBasicBlock::PeepholeOptimization(void)
 		while (i < mInstructions.Size())
 		{
 			// move stores up
-			if (mInstructions[i].mCode == IC_STORE)
+			if (mInstructions[i]->mCode == IC_STORE)
 			{
-				InterInstruction	ins(mInstructions[i]);
+				InterInstruction	*	ins(mInstructions[i]);
 				int j = i;
 				while (j > 0 && CanBypassStore(ins, mInstructions[j - 1]))
 				{
@@ -3107,7 +3110,7 @@ void InterCodeBasicBlock::PeepholeOptimization(void)
 			int	j = 0;
 			for (i = 0; i < mInstructions.Size(); i++)
 			{
-				if (mInstructions[i].mCode != IC_NONE)
+				if (mInstructions[i]->mCode != IC_NONE)
 				{
 					mInstructions[j++] = mInstructions[i];
 				}
@@ -3120,75 +3123,75 @@ void InterCodeBasicBlock::PeepholeOptimization(void)
 			{
 				if (i + 2 < mInstructions.Size())
 				{
-					if (mInstructions[i + 0].mTTemp >= 0 &&
-						mInstructions[i + 1].mCode == IC_LOAD_TEMPORARY && mInstructions[i + 1].mSTemp[0] == mInstructions[i].mTTemp &&
-						(mInstructions[i + 2].mCode == IC_RELATIONAL_OPERATOR || mInstructions[i + 2].mCode == IC_BINARY_OPERATOR) && mInstructions[i + 2].mSTemp[0] == mInstructions[i].mTTemp && mInstructions[i + 2].mSFinal[0])
+					if (mInstructions[i + 0]->mTTemp >= 0 &&
+						mInstructions[i + 1]->mCode == IC_LOAD_TEMPORARY && mInstructions[i + 1]->mSTemp[0] == mInstructions[i]->mTTemp &&
+						(mInstructions[i + 2]->mCode == IC_RELATIONAL_OPERATOR || mInstructions[i + 2]->mCode == IC_BINARY_OPERATOR) && mInstructions[i + 2]->mSTemp[0] == mInstructions[i]->mTTemp && mInstructions[i + 2]->mSFinal[0])
 					{
-						mInstructions[i + 0].mTTemp = mInstructions[i + 1].mTTemp;
-						mInstructions[i + 1].mCode = IC_NONE;
-						mInstructions[i + 2].mSTemp[0] = mInstructions[i + 1].mTTemp;
-						mInstructions[i + 2].mSFinal[0] = false;
+						mInstructions[i + 0]->mTTemp = mInstructions[i + 1]->mTTemp;
+						mInstructions[i + 1]->mCode = IC_NONE;
+						mInstructions[i + 2]->mSTemp[0] = mInstructions[i + 1]->mTTemp;
+						mInstructions[i + 2]->mSFinal[0] = false;
 						changed = true;
 					}
-					else if (mInstructions[i + 0].mTTemp >= 0 &&
-						mInstructions[i + 1].mCode == IC_LOAD_TEMPORARY && mInstructions[i + 1].mSTemp[0] == mInstructions[i].mTTemp &&
-						(mInstructions[i + 2].mCode == IC_RELATIONAL_OPERATOR || mInstructions[i + 2].mCode == IC_BINARY_OPERATOR) && mInstructions[i + 2].mSTemp[1] == mInstructions[i].mTTemp && mInstructions[i + 2].mSFinal[1])
+					else if (mInstructions[i + 0]->mTTemp >= 0 &&
+						mInstructions[i + 1]->mCode == IC_LOAD_TEMPORARY && mInstructions[i + 1]->mSTemp[0] == mInstructions[i]->mTTemp &&
+						(mInstructions[i + 2]->mCode == IC_RELATIONAL_OPERATOR || mInstructions[i + 2]->mCode == IC_BINARY_OPERATOR) && mInstructions[i + 2]->mSTemp[1] == mInstructions[i]->mTTemp && mInstructions[i + 2]->mSFinal[1])
 					{
-						mInstructions[i + 0].mTTemp = mInstructions[i + 1].mTTemp;
-						mInstructions[i + 1].mCode = IC_NONE;
-						mInstructions[i + 2].mSTemp[1] = mInstructions[i + 1].mTTemp;
-						mInstructions[i + 2].mSFinal[1] = false;
+						mInstructions[i + 0]->mTTemp = mInstructions[i + 1]->mTTemp;
+						mInstructions[i + 1]->mCode = IC_NONE;
+						mInstructions[i + 2]->mSTemp[1] = mInstructions[i + 1]->mTTemp;
+						mInstructions[i + 2]->mSFinal[1] = false;
 						changed = true;
 					}
 					else if (
-						mInstructions[i + 0].mCode == IC_BINARY_OPERATOR && mInstructions[i + 0].mOperator == IA_SAR && mInstructions[i + 0].mSTemp[0] < 0 &&
-						mInstructions[i + 1].mCode == IC_BINARY_OPERATOR && mInstructions[i + 1].mOperator == IA_MUL && mInstructions[i + 1].mSTemp[0] < 0 &&
-						mInstructions[i + 1].mSTemp[1] == mInstructions[i + 0].mTTemp && mInstructions[i + 1].mSFinal[1] &&
-						(mInstructions[i + 1].mSIntConst[0] & (1LL << mInstructions[i + 0].mSIntConst[0])) == 0)
+						mInstructions[i + 0]->mCode == IC_BINARY_OPERATOR && mInstructions[i + 0]->mOperator == IA_SAR && mInstructions[i + 0]->mSTemp[0] < 0 &&
+						mInstructions[i + 1]->mCode == IC_BINARY_OPERATOR && mInstructions[i + 1]->mOperator == IA_MUL && mInstructions[i + 1]->mSTemp[0] < 0 &&
+						mInstructions[i + 1]->mSTemp[1] == mInstructions[i + 0]->mTTemp && mInstructions[i + 1]->mSFinal[1] &&
+						(mInstructions[i + 1]->mSIntConst[0] & (1LL << mInstructions[i + 0]->mSIntConst[0])) == 0)
 					{
-						int	shift = mInstructions[i + 0].mSIntConst[0];
-						mInstructions[i + 1].mSIntConst[0] >>= shift;
-						mInstructions[i + 0].mOperator = IA_AND;
-						mInstructions[i + 0].mSIntConst[0] = ~((1LL << shift) - 1);
+						int	shift = mInstructions[i + 0]->mSIntConst[0];
+						mInstructions[i + 1]->mSIntConst[0] >>= shift;
+						mInstructions[i + 0]->mOperator = IA_AND;
+						mInstructions[i + 0]->mSIntConst[0] = ~((1LL << shift) - 1);
 						changed = true;
 					}
 					else if (
-						mInstructions[i + 0].mCode == IC_BINARY_OPERATOR && mInstructions[i + 0].mOperator == IA_SAR && mInstructions[i + 0].mSTemp[0] < 0 &&
-						mInstructions[i + 1].mCode == IC_BINARY_OPERATOR && mInstructions[i + 1].mOperator == IA_MUL && mInstructions[i + 1].mSTemp[1] < 0 &&
-						mInstructions[i + 1].mSTemp[0] == mInstructions[i + 0].mTTemp && mInstructions[i + 1].mSFinal[0] &&
-						(mInstructions[i + 1].mSIntConst[1] & (1LL << mInstructions[i + 0].mSIntConst[0])) == 0)
+						mInstructions[i + 0]->mCode == IC_BINARY_OPERATOR && mInstructions[i + 0]->mOperator == IA_SAR && mInstructions[i + 0]->mSTemp[0] < 0 &&
+						mInstructions[i + 1]->mCode == IC_BINARY_OPERATOR && mInstructions[i + 1]->mOperator == IA_MUL && mInstructions[i + 1]->mSTemp[1] < 0 &&
+						mInstructions[i + 1]->mSTemp[0] == mInstructions[i + 0]->mTTemp && mInstructions[i + 1]->mSFinal[0] &&
+						(mInstructions[i + 1]->mSIntConst[1] & (1LL << mInstructions[i + 0]->mSIntConst[0])) == 0)
 					{
-						int	shift = mInstructions[i + 0].mSIntConst[0];
-						mInstructions[i + 1].mSIntConst[1] >>= shift;
-						mInstructions[i + 0].mOperator = IA_AND;
-						mInstructions[i + 0].mSIntConst[0] = ~((1LL << shift) - 1);
+						int	shift = mInstructions[i + 0]->mSIntConst[0];
+						mInstructions[i + 1]->mSIntConst[1] >>= shift;
+						mInstructions[i + 0]->mOperator = IA_AND;
+						mInstructions[i + 0]->mSIntConst[0] = ~((1LL << shift) - 1);
 						changed = true;
 					}
 					else if (
-						mInstructions[i + 1].mCode == IC_LOAD_TEMPORARY && mExitRequiredTemps[mInstructions[i + 1].mTTemp] && !mExitRequiredTemps[mInstructions[i + 1].mSTemp[0]] &&
-						mInstructions[i + 0].mTTemp == mInstructions[i + 1].mSTemp[0])
+						mInstructions[i + 1]->mCode == IC_LOAD_TEMPORARY && mExitRequiredTemps[mInstructions[i + 1]->mTTemp] && !mExitRequiredTemps[mInstructions[i + 1]->mSTemp[0]] &&
+						mInstructions[i + 0]->mTTemp == mInstructions[i + 1]->mSTemp[0])
 					{
-						mInstructions[i + 0].mTTemp = mInstructions[i + 1].mTTemp;
-						mInstructions[i + 1].mTTemp = mInstructions[i + 1].mSTemp[0];
-						mInstructions[i + 1].mSTemp[0] = mInstructions[i + 0].mTTemp;
+						mInstructions[i + 0]->mTTemp = mInstructions[i + 1]->mTTemp;
+						mInstructions[i + 1]->mTTemp = mInstructions[i + 1]->mSTemp[0];
+						mInstructions[i + 1]->mSTemp[0] = mInstructions[i + 0]->mTTemp;
 						changed = true;
 					}
 
 					// Postincrement artifact
-					if (mInstructions[i + 0].mCode == IC_LOAD_TEMPORARY && mInstructions[i + 1].mCode == IC_BINARY_OPERATOR &&
-						mInstructions[i + 1].mSTemp[0] < 0 &&
-						mInstructions[i + 0].mSTemp[0] == mInstructions[i + 1].mSTemp[1] &&
-						mInstructions[i + 0].mSTemp[0] == mInstructions[i + 1].mTTemp)
+					if (mInstructions[i + 0]->mCode == IC_LOAD_TEMPORARY && mInstructions[i + 1]->mCode == IC_BINARY_OPERATOR &&
+						mInstructions[i + 1]->mSTemp[0] < 0 &&
+						mInstructions[i + 0]->mSTemp[0] == mInstructions[i + 1]->mSTemp[1] &&
+						mInstructions[i + 0]->mSTemp[0] == mInstructions[i + 1]->mTTemp)
 					{
-						InterInstruction	ins = mInstructions[i + 1];
-						int		ttemp = mInstructions[i + 1].mTTemp;
+						InterInstruction	*	ins = mInstructions[i + 1];
+						int		ttemp = mInstructions[i + 1]->mTTemp;
 						int	k = i + 1;
 						while (k + 2 < mInstructions.Size() &&
-							mInstructions[k + 1].mCode != IC_RELATIONAL_OPERATOR &&
-							mInstructions[k + 1].mSTemp[0] != ttemp &&
-							mInstructions[k + 1].mSTemp[1] != ttemp &&
-							mInstructions[k + 1].mSTemp[2] != ttemp &&
-							mInstructions[k + 1].mTTemp != ttemp)
+							mInstructions[k + 1]->mCode != IC_RELATIONAL_OPERATOR &&
+							mInstructions[k + 1]->mSTemp[0] != ttemp &&
+							mInstructions[k + 1]->mSTemp[1] != ttemp &&
+							mInstructions[k + 1]->mSTemp[2] != ttemp &&
+							mInstructions[k + 1]->mTTemp != ttemp)
 						{
 							mInstructions[k] = mInstructions[k + 1];
 							k++;
@@ -3224,19 +3227,19 @@ void InterCodeBasicBlock::CollectVariables(GrowingVariableArray& globalVars, Gro
 		{
 			bool	found = false;
 
-			switch (mInstructions[i].mCode)
+			switch (mInstructions[i]->mCode)
 			{
 			case IC_STORE:
 			case IC_LOAD:							
 			case IC_CONSTANT:
 			case IC_JSR:
-				if (mInstructions[i].mMemory == IM_LOCAL)
+				if (mInstructions[i]->mMemory == IM_LOCAL)
 				{
-					int	size = mInstructions[i].mOperandSize + mInstructions[i].mIntValue;
-					if (size > localVars[mInstructions[i].mVarIndex].mSize)
-						localVars[mInstructions[i].mVarIndex].mSize = size;
-					if (mInstructions[i].mCode == IC_CONSTANT)
-						localVars[mInstructions[i].mVarIndex].mAliased = true;
+					int	size = mInstructions[i]->mOperandSize + mInstructions[i]->mIntValue;
+					if (size > localVars[mInstructions[i]->mVarIndex].mSize)
+						localVars[mInstructions[i]->mVarIndex].mSize = size;
+					if (mInstructions[i]->mCode == IC_CONSTANT)
+						localVars[mInstructions[i]->mVarIndex].mAliased = true;
 				}
 				break;
 			}
@@ -3257,7 +3260,7 @@ void InterCodeBasicBlock::CollectSimpleLocals(FastNumberSet& complexLocals, Fast
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			mInstructions[i].CollectSimpleLocals(complexLocals, simpleLocals, localTypes, complexParams, simpleParams, paramTypes);
+			mInstructions[i]->CollectSimpleLocals(complexLocals, simpleLocals, localTypes, complexParams, simpleParams, paramTypes);
 		}
 
 		if (mTrueJump) mTrueJump->CollectSimpleLocals(complexLocals, simpleLocals, localTypes, complexParams, simpleParams, paramTypes);
@@ -3275,7 +3278,7 @@ void InterCodeBasicBlock::SimpleLocalToTemp(int vindex, int temp)
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			mInstructions[i].SimpleLocalToTemp(vindex, temp);
+			mInstructions[i]->SimpleLocalToTemp(vindex, temp);
 		}
 
 		if (mTrueJump) mTrueJump->SimpleLocalToTemp(vindex, temp);
@@ -3294,7 +3297,7 @@ void InterCodeBasicBlock::CollectActiveTemporaries(FastNumberSet& set)
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			mInstructions[i].CollectActiveTemporaries(set);
+			mInstructions[i]->CollectActiveTemporaries(set);
 		}
 
 		if (mTrueJump) mTrueJump->CollectActiveTemporaries(set);
@@ -3312,7 +3315,7 @@ void InterCodeBasicBlock::ShrinkActiveTemporaries(FastNumberSet& set, GrowingTyp
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			mInstructions[i].ShrinkActiveTemporaries(set, temporaries);
+			mInstructions[i]->ShrinkActiveTemporaries(set, temporaries);
 		}
 
 		if (mTrueJump) mTrueJump->ShrinkActiveTemporaries(set, temporaries);
@@ -3346,10 +3349,10 @@ void InterCodeBasicBlock::Disassemble(FILE* file, bool dumpSets)
 
 		for (i = 0; i < mInstructions.Size(); i++)
 		{
-			if (mInstructions[i].mCode != IT_NONE)
+			if (mInstructions[i]->mCode != IT_NONE)
 			{
 				fprintf(file, "%04x\t", i);
-				mInstructions[i].Disassemble(file);
+				mInstructions[i]->Disassemble(file);
 			}
 		}
 
diff --git a/oscar64/InterCode.h b/oscar64/InterCode.h
index d858e7e4..bfd98ed4 100644
--- a/oscar64/InterCode.h
+++ b/oscar64/InterCode.h
@@ -115,7 +115,7 @@ typedef GrowingArray<InterType>					GrowingTypeArray;
 typedef GrowingArray<int>						GrowingIntArray;
 typedef GrowingArray<InterInstructionPtr>		GrowingInstructionPtrArray;
 typedef GrowingArray<InterCodeBasicBlockPtr>	GrowingInterCodeBasicBlockPtrArray;
-typedef GrowingArray<InterInstruction>			GrowingInstructionArray;
+typedef GrowingArray<InterInstruction *>		GrowingInstructionArray;
 typedef GrowingArray<InterCodeProcedurePtr	>	GrowingInterCodeProcedurePtrArray;
 
 
@@ -139,9 +139,9 @@ class ValueSet
 	void FlushCallAliases(void);
 
 	void RemoveValue(int index);
-	void InsertValue(InterInstruction& ins);
+	void InsertValue(InterInstruction * ins);
 
-	void UpdateValue(InterInstruction& ins, const GrowingInstructionPtrArray& tvalue, const NumberSet& aliasedLocals, const NumberSet& aliasedParams);
+	void UpdateValue(InterInstruction * ins, const GrowingInstructionPtrArray& tvalue, const NumberSet& aliasedLocals, const NumberSet& aliasedParams);
 	void Intersect(ValueSet& set);
 };
 
@@ -308,7 +308,10 @@ class InterInstruction
 	double								mFloatValue;
 	Location							mLocation;
 
+	bool								mInUse;
+
 	InterInstruction(void);
+
 	void SetCode(const Location & loc, InterCode code);
 
 	void CollectLocalAddressTemps(GrowingIntArray& localTable, GrowingIntArray& paramTable);
@@ -408,7 +411,7 @@ class InterCodeBasicBlock
 	InterCodeBasicBlock(void);
 	~InterCodeBasicBlock(void);
 
-	void Append(InterInstruction & code);
+	void Append(InterInstruction * code);
 	void Close(InterCodeBasicBlock* trueJump, InterCodeBasicBlock* falseJump);
 
 	void CollectEntries(void);
@@ -440,7 +443,7 @@ class InterCodeBasicBlock
 	void BuildGlobalRenameRegisterTable(const GrowingIntArray& renameTable, GrowingIntArray& globalRenameTable);
 	void GlobalRenameRegister(const GrowingIntArray& renameTable, GrowingTypeArray& temporaries);
 
-	void CheckValueUsage(InterInstruction& ins, const GrowingInstructionPtrArray& tvalue);
+	void CheckValueUsage(InterInstruction * ins, const GrowingInstructionPtrArray& tvalue);
 	void PerformTempForwarding(TempForwardingTable& forwardingTable);
 	void PerformValueForwarding(const GrowingInstructionPtrArray& tvalue, const ValueSet& values, FastNumberSet& tvalid, const NumberSet& aliasedLocals, const NumberSet& aliasedParams);
 	void PerformMachineSpecificValueUsageCheck(const GrowingInstructionPtrArray& tvalue, FastNumberSet& tvalid);
diff --git a/oscar64/InterCodeGenerator.cpp b/oscar64/InterCodeGenerator.cpp
index f236b14c..ef9a653e 100644
--- a/oscar64/InterCodeGenerator.cpp
+++ b/oscar64/InterCodeGenerator.cpp
@@ -43,17 +43,17 @@ InterCodeGenerator::ExValue InterCodeGenerator::Dereference(InterCodeProcedure*
 {
 	while (v.mReference > level)
 	{
-		InterInstruction	ins;
-		ins.mCode = IC_LOAD;
-		ins.mMemory = IM_INDIRECT;
-		ins.mSType[0] = IT_POINTER;
-		ins.mSTemp[0] = v.mTemp;
-		ins.mTType = v.mReference == 1 ? InterTypeOf(v.mType) : IT_POINTER;
-		ins.mTTemp = proc->AddTemporary(ins.mTType);
-		ins.mOperandSize = v.mReference == 1 ? v.mType->mSize : 2;
+		InterInstruction	*	ins = new InterInstruction();
+		ins->mCode = IC_LOAD;
+		ins->mMemory = IM_INDIRECT;
+		ins->mSType[0] = IT_POINTER;
+		ins->mSTemp[0] = v.mTemp;
+		ins->mTType = v.mReference == 1 ? InterTypeOf(v.mType) : IT_POINTER;
+		ins->mTTemp = proc->AddTemporary(ins->mTType);
+		ins->mOperandSize = v.mReference == 1 ? v.mType->mSize : 2;
 		block->Append(ins);
 
-		v = ExValue(v.mType, ins.mTTemp, v.mReference - 1);
+		v = ExValue(v.mType, ins->mTTemp, v.mReference - 1);
 	}
 
 	return v;
@@ -69,53 +69,53 @@ InterCodeGenerator::ExValue InterCodeGenerator::CoerceType(InterCodeProcedure* p
 		{
 			if (v.mType->mFlags & DTF_SIGNED)
 			{
-				InterInstruction	xins;
-				xins.mCode = IC_CONVERSION_OPERATOR;
-				xins.mOperator = IA_EXT8TO16S;
-				xins.mSType[0] = IT_INT8;
-				xins.mSTemp[0] = stemp;
-				xins.mTType = IT_INT16;
-				xins.mTTemp = proc->AddTemporary(IT_INT16);
+				InterInstruction	*	xins = new InterInstruction();
+				xins->mCode = IC_CONVERSION_OPERATOR;
+				xins->mOperator = IA_EXT8TO16S;
+				xins->mSType[0] = IT_INT8;
+				xins->mSTemp[0] = stemp;
+				xins->mTType = IT_INT16;
+				xins->mTTemp = proc->AddTemporary(IT_INT16);
 				block->Append(xins);
-				stemp = xins.mTTemp;
+				stemp = xins->mTTemp;
 			}
 			else
 			{
-				InterInstruction	xins;
-				xins.mCode = IC_CONVERSION_OPERATOR;
-				xins.mOperator = IA_EXT8TO16U;
-				xins.mSType[0] = IT_INT8;
-				xins.mSTemp[0] = stemp;
-				xins.mTType = IT_INT16;
-				xins.mTTemp = proc->AddTemporary(IT_INT16);
+				InterInstruction	*	xins = new InterInstruction();
+				xins->mCode = IC_CONVERSION_OPERATOR;
+				xins->mOperator = IA_EXT8TO16U;
+				xins->mSType[0] = IT_INT8;
+				xins->mSTemp[0] = stemp;
+				xins->mTType = IT_INT16;
+				xins->mTTemp = proc->AddTemporary(IT_INT16);
 				block->Append(xins);
-				stemp = xins.mTTemp;
+				stemp = xins->mTTemp;
 			}
 		}
 
-		InterInstruction	cins;
-		cins.mCode = IC_CONVERSION_OPERATOR;
-		cins.mOperator = IA_INT2FLOAT;
-		cins.mSType[0] = IT_INT16;
-		cins.mSTemp[0] = stemp;
-		cins.mTType = IT_FLOAT;
-		cins.mTTemp = proc->AddTemporary(IT_FLOAT);
+		InterInstruction	*	cins = new InterInstruction();
+		cins->mCode = IC_CONVERSION_OPERATOR;
+		cins->mOperator = IA_INT2FLOAT;
+		cins->mSType[0] = IT_INT16;
+		cins->mSTemp[0] = stemp;
+		cins->mTType = IT_FLOAT;
+		cins->mTTemp = proc->AddTemporary(IT_FLOAT);
 		block->Append(cins);
 
-		v.mTemp = cins.mTTemp;
+		v.mTemp = cins->mTTemp;
 		v.mType = type;
 	}
 	else if (v.mType->mType == DT_TYPE_FLOAT && type->IsIntegerType())
 	{
-		InterInstruction	cins;
-		cins.mCode = IC_CONVERSION_OPERATOR;
-		cins.mOperator = IA_FLOAT2INT;
-		cins.mSType[0] = IT_FLOAT;
-		cins.mSTemp[0] = v.mTemp;
-		cins.mTType = IT_INT16;
-		cins.mTTemp = proc->AddTemporary(IT_INT16);
+		InterInstruction	*	cins = new InterInstruction();
+		cins->mCode = IC_CONVERSION_OPERATOR;
+		cins->mOperator = IA_FLOAT2INT;
+		cins->mSType[0] = IT_FLOAT;
+		cins->mSTemp[0] = v.mTemp;
+		cins->mTType = IT_INT16;
+		cins->mTTemp = proc->AddTemporary(IT_INT16);
 		block->Append(cins);
-		v.mTemp = cins.mTTemp;
+		v.mTemp = cins->mTTemp;
 		v.mType = type;
 	}
 	else if (v.mType->mSize < type->mSize)
@@ -124,27 +124,27 @@ InterCodeGenerator::ExValue InterCodeGenerator::CoerceType(InterCodeProcedure* p
 		{
 			if (v.mType->mFlags & DTF_SIGNED)
 			{
-				InterInstruction	xins;
-				xins.mCode = IC_CONVERSION_OPERATOR;
-				xins.mOperator = IA_EXT8TO16S;
-				xins.mSType[0] = IT_INT8;
-				xins.mSTemp[0] = stemp;
-				xins.mTType = IT_INT16;
-				xins.mTTemp = proc->AddTemporary(IT_INT16);
+				InterInstruction	*	xins = new InterInstruction();
+				xins->mCode = IC_CONVERSION_OPERATOR;
+				xins->mOperator = IA_EXT8TO16S;
+				xins->mSType[0] = IT_INT8;
+				xins->mSTemp[0] = stemp;
+				xins->mTType = IT_INT16;
+				xins->mTTemp = proc->AddTemporary(IT_INT16);
 				block->Append(xins);
-				stemp = xins.mTTemp;
+				stemp = xins->mTTemp;
 			}
 			else
 			{
-				InterInstruction	xins;
-				xins.mCode = IC_CONVERSION_OPERATOR;
-				xins.mOperator = IA_EXT8TO16U;
-				xins.mSType[0] = IT_INT8;
-				xins.mSTemp[0] = stemp;
-				xins.mTType = IT_INT16;
-				xins.mTTemp = proc->AddTemporary(IT_INT16);
+				InterInstruction	*	xins = new InterInstruction();
+				xins->mCode = IC_CONVERSION_OPERATOR;
+				xins->mOperator = IA_EXT8TO16U;
+				xins->mSType[0] = IT_INT8;
+				xins->mSTemp[0] = stemp;
+				xins->mTType = IT_INT16;
+				xins->mTTemp = proc->AddTemporary(IT_INT16);
 				block->Append(xins);
-				stemp = xins.mTTemp;
+				stemp = xins->mTTemp;
 			}
 		}
 
@@ -432,11 +432,11 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			{
 			case DT_CONST_INTEGER:
 				{
-				InterInstruction	ins;
-				ins.mCode = IC_CONSTANT;
-				ins.mTType = InterTypeOf(dec->mBase);
-				ins.mTTemp = proc->AddTemporary(ins.mTType);
-				if (ins.mTType == IT_INT8)
+				InterInstruction	*	ins = new InterInstruction();
+				ins->mCode = IC_CONSTANT;
+				ins->mTType = InterTypeOf(dec->mBase);
+				ins->mTTemp = proc->AddTemporary(ins->mTType);
+				if (ins->mTType == IT_INT8)
 				{
 					if (dec->mFlags & DTF_SIGNED)
 					{
@@ -448,9 +448,9 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 						if (dec->mInteger < 0 || dec->mInteger > 255)
 							mErrors->Warning(dec->mLocation, "Unsigned integer constant truncated");
 					}
-					ins.mIntValue = char(dec->mInteger);
+					ins->mIntValue = char(dec->mInteger);
 				}
-				else if (ins.mTType == IT_INT8)
+				else if (ins->mTType == IT_INT8)
 				{
 					if (dec->mFlags & DTF_SIGNED)
 					{
@@ -462,39 +462,39 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 						if (dec->mInteger < 0 || dec->mInteger > 65535)
 							mErrors->Warning(dec->mLocation, "Unsigned integer constant truncated");
 					}
-					ins.mIntValue = short(dec->mInteger);
+					ins->mIntValue = short(dec->mInteger);
 				}
 				else
 				{
-					ins.mIntValue = dec->mInteger;
+					ins->mIntValue = dec->mInteger;
 				}
 				block->Append(ins);
-				return ExValue(dec->mBase, ins.mTTemp);
+				return ExValue(dec->mBase, ins->mTTemp);
 
 			} break;
 
 			case DT_CONST_FLOAT:
 				{
-				InterInstruction	ins;
-				ins.mCode = IC_CONSTANT;
-				ins.mTType = InterTypeOf(dec->mBase);
-				ins.mTTemp = proc->AddTemporary(ins.mTType);
-				ins.mFloatValue = dec->mNumber;
+				InterInstruction	*	ins = new InterInstruction();
+				ins->mCode = IC_CONSTANT;
+				ins->mTType = InterTypeOf(dec->mBase);
+				ins->mTTemp = proc->AddTemporary(ins->mTType);
+				ins->mFloatValue = dec->mNumber;
 				block->Append(ins);
-				return ExValue(dec->mBase, ins.mTTemp);
+				return ExValue(dec->mBase, ins->mTTemp);
 
 			} break;
 
 			case DT_CONST_ADDRESS:
 			{
-				InterInstruction	ins;
-				ins.mCode = IC_CONSTANT;
-				ins.mTType = IT_POINTER;
-				ins.mTTemp = proc->AddTemporary(IT_POINTER);
-				ins.mIntValue = dec->mInteger;
-				ins.mMemory = IM_ABSOLUTE;
+				InterInstruction	*	ins = new InterInstruction();
+				ins->mCode = IC_CONSTANT;
+				ins->mTType = IT_POINTER;
+				ins->mTTemp = proc->AddTemporary(IT_POINTER);
+				ins->mIntValue = dec->mInteger;
+				ins->mMemory = IM_ABSOLUTE;
 				block->Append(ins);
-				return ExValue(dec->mBase, ins.mTTemp);
+				return ExValue(dec->mBase, ins->mTTemp);
 
 			} break;
 
@@ -506,15 +506,15 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 					cproc->ReduceTemporaries();
 				}
 
-				InterInstruction	ins;
-				ins.mCode = IC_CONSTANT;
-				ins.mTType = InterTypeOf(dec->mBase);
-				ins.mTTemp = proc->AddTemporary(ins.mTType);
-				ins.mVarIndex = dec->mVarIndex;
-				ins.mMemory = IM_PROCEDURE;
-				ins.mIntValue = 0;
+				InterInstruction	*	ins = new InterInstruction();
+				ins->mCode = IC_CONSTANT;
+				ins->mTType = InterTypeOf(dec->mBase);
+				ins->mTTemp = proc->AddTemporary(ins->mTType);
+				ins->mVarIndex = dec->mVarIndex;
+				ins->mMemory = IM_PROCEDURE;
+				ins->mIntValue = 0;
 				block->Append(ins);
-				return ExValue(dec->mBase, ins.mTTemp);
+				return ExValue(dec->mBase, ins->mTTemp);
 
 			} break;
 
@@ -537,15 +537,15 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 					proc->mModule->mGlobalVars.Push(var);
 				}
 
-				InterInstruction	ins;
-				ins.mCode = IC_CONSTANT;
-				ins.mTType = IT_POINTER;
-				ins.mTTemp = proc->AddTemporary(IT_POINTER);
-				ins.mIntValue = 0;
-				ins.mVarIndex = dec->mVarIndex;
-				ins.mMemory = IM_GLOBAL;
+				InterInstruction	*	ins = new InterInstruction();
+				ins->mCode = IC_CONSTANT;
+				ins->mTType = IT_POINTER;
+				ins->mTTemp = proc->AddTemporary(IT_POINTER);
+				ins->mIntValue = 0;
+				ins->mVarIndex = dec->mVarIndex;
+				ins->mMemory = IM_GLOBAL;
 				block->Append(ins);
-				return ExValue(dec->mBase, ins.mTTemp, 1);
+				return ExValue(dec->mBase, ins->mTTemp, 1);
 			}
 
 			case DT_CONST_STRUCT:
@@ -577,15 +577,15 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 					proc->mModule->mGlobalVars.Push(var);
 				}
 
-				InterInstruction	ins;
-				ins.mCode = IC_CONSTANT;
-				ins.mTType = IT_POINTER;
-				ins.mTTemp = proc->AddTemporary(IT_POINTER);
-				ins.mIntValue = 0;
-				ins.mVarIndex = dec->mVarIndex;
-				ins.mMemory = IM_GLOBAL;
+				InterInstruction	*	ins = new InterInstruction();
+				ins->mCode = IC_CONSTANT;
+				ins->mTType = IT_POINTER;
+				ins->mTTemp = proc->AddTemporary(IT_POINTER);
+				ins->mIntValue = 0;
+				ins->mVarIndex = dec->mVarIndex;
+				ins->mMemory = IM_GLOBAL;
 				block->Append(ins);
-				return ExValue(dec->mBase, ins.mTTemp, 1);
+				return ExValue(dec->mBase, ins->mTTemp, 1);
 			}
 
 			default:
@@ -598,29 +598,29 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 		{
 			dec = exp->mDecValue;
 			
-			InterInstruction	ins;
-			ins.mCode = IC_CONSTANT;
-			ins.mTType = IT_POINTER;
-			ins.mTTemp = proc->AddTemporary(ins.mTType);
-			ins.mOperandSize = dec->mSize;
-			ins.mIntValue = dec->mOffset;
+			InterInstruction	*	ins = new InterInstruction();
+			ins->mCode = IC_CONSTANT;
+			ins->mTType = IT_POINTER;
+			ins->mTTemp = proc->AddTemporary(ins->mTType);
+			ins->mOperandSize = dec->mSize;
+			ins->mIntValue = dec->mOffset;
 			if (dec->mType == DT_ARGUMENT)
-				ins.mMemory = IM_PARAM;
+				ins->mMemory = IM_PARAM;
 			else if (dec->mFlags & DTF_GLOBAL)
 			{
 				InitGlobalVariable(proc->mModule, dec);
-				ins.mMemory = IM_GLOBAL;
+				ins->mMemory = IM_GLOBAL;
 			}
 			else
-				ins.mMemory = IM_LOCAL;
-			ins.mVarIndex = dec->mVarIndex;
+				ins->mMemory = IM_LOCAL;
+			ins->mVarIndex = dec->mVarIndex;
 
 			block->Append(ins);
 
 			if (!(dec->mBase->mFlags & DTF_DEFINED))
 				mErrors->Error(dec->mLocation, "Undefined variable type");
 
-			return ExValue(dec->mBase, ins.mTTemp, 1);
+			return ExValue(dec->mBase, ins->mTTemp, 1);
 		}
 
 
@@ -649,14 +649,14 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 					mErrors->Error(exp->mLeft->mLocation, "Not an adressable expression");
 
 				
-				InterInstruction	ins;
-				ins.mCode = IC_COPY;
-				ins.mMemory = IM_INDIRECT;
-				ins.mSType[0] = IT_POINTER;
-				ins.mSTemp[0] = vr.mTemp;
-				ins.mSType[1] = IT_POINTER;
-				ins.mSTemp[1] = vl.mTemp;
-				ins.mOperandSize = vl.mType->mSize;
+				InterInstruction	*	ins = new InterInstruction();
+				ins->mCode = IC_COPY;
+				ins->mMemory = IM_INDIRECT;
+				ins->mSType[0] = IT_POINTER;
+				ins->mSTemp[0] = vr.mTemp;
+				ins->mSType[1] = IT_POINTER;
+				ins->mSTemp[1] = vl.mTemp;
+				ins->mOperandSize = vl.mType->mSize;
 				block->Append(ins);
 			}
 			else
@@ -671,7 +671,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 				if (vl.mReference != 1)
 					mErrors->Error(exp->mLeft->mLocation, "Not a left hand expression");
 
-				InterInstruction	ins;
+				InterInstruction	*	ins = new InterInstruction();
 
 				if (exp->mToken != TK_ASSIGN)
 				{
@@ -679,16 +679,16 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 					if (vl.mType->mType == DT_TYPE_POINTER)
 					{
-						InterInstruction	cins;
-						cins.mCode = IC_CONSTANT;
+						InterInstruction	*	cins = new InterInstruction();
+						cins->mCode = IC_CONSTANT;
 
 						if (exp->mToken == TK_ASSIGN_ADD)
 						{
-							cins.mIntValue = vl.mType->mBase->mSize;
+							cins->mIntValue = vl.mType->mBase->mSize;
 						}
 						else if (exp->mToken == TK_ASSIGN_SUB)
 						{
-							cins.mIntValue = -vl.mType->mBase->mSize;
+							cins->mIntValue = -vl.mType->mBase->mSize;
 						}
 						else
 							mErrors->Error(exp->mLocation, "Invalid pointer assignment");
@@ -696,47 +696,47 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 						if (!vr.mType->IsIntegerType())
 							mErrors->Error(exp->mLocation, "Invalid argument for pointer inc/dec");
 
-						cins.mTType = IT_INT16;
-						cins.mTTemp = proc->AddTemporary(cins.mTType);
+						cins->mTType = IT_INT16;
+						cins->mTTemp = proc->AddTemporary(cins->mTType);
 						block->Append(cins);
 
-						InterInstruction	mins;
-						mins.mCode = IC_BINARY_OPERATOR;
-						mins.mOperator = IA_MUL;
-						mins.mSType[0] = IT_INT16;
-						mins.mSTemp[0] = vr.mTemp;
-						mins.mSType[1] = IT_INT16;
-						mins.mSTemp[1] = cins.mTTemp;
-						mins.mTType = IT_INT16;
-						mins.mTTemp = proc->AddTemporary(mins.mTType);
+						InterInstruction	*	mins = new InterInstruction();
+						mins->mCode = IC_BINARY_OPERATOR;
+						mins->mOperator = IA_MUL;
+						mins->mSType[0] = IT_INT16;
+						mins->mSTemp[0] = vr.mTemp;
+						mins->mSType[1] = IT_INT16;
+						mins->mSTemp[1] = cins->mTTemp;
+						mins->mTType = IT_INT16;
+						mins->mTTemp = proc->AddTemporary(mins->mTType);
 						block->Append(mins);
 
-						InterInstruction	ains;
-						ains.mCode = IC_LEA;
-						ains.mMemory = IM_INDIRECT;
-						ains.mSType[0] = IT_INT16;
-						ains.mSTemp[0] = mins.mTTemp;
-						ains.mSType[1] = IT_POINTER;
-						ains.mSTemp[1] = vll.mTemp;
-						ains.mTType = IT_POINTER;
-						ains.mTTemp = proc->AddTemporary(ains.mTType);
+						InterInstruction	*	ains = new InterInstruction();
+						ains->mCode = IC_LEA;
+						ains->mMemory = IM_INDIRECT;
+						ains->mSType[0] = IT_INT16;
+						ains->mSTemp[0] = mins->mTTemp;
+						ains->mSType[1] = IT_POINTER;
+						ains->mSTemp[1] = vll.mTemp;
+						ains->mTType = IT_POINTER;
+						ains->mTTemp = proc->AddTemporary(ains->mTType);
 						block->Append(ains);
 
-						vr.mTemp = ains.mTTemp;
+						vr.mTemp = ains->mTTemp;
 						vr.mType = vll.mType;
 					}
 					else
 					{
 						vr = CoerceType(proc, block, vr, vll.mType);
 
-						InterInstruction	oins;
-						oins.mCode = IC_BINARY_OPERATOR;
-						oins.mSType[0] = InterTypeOf(vr.mType);
-						oins.mSTemp[0] = vr.mTemp;
-						oins.mSType[1] = InterTypeOf(vll.mType);
-						oins.mSTemp[1] = vll.mTemp;
-						oins.mTType = InterTypeOf(vll.mType);
-						oins.mTTemp = proc->AddTemporary(oins.mTType);
+						InterInstruction	*	oins = new InterInstruction();
+						oins->mCode = IC_BINARY_OPERATOR;
+						oins->mSType[0] = InterTypeOf(vr.mType);
+						oins->mSTemp[0] = vr.mTemp;
+						oins->mSType[1] = InterTypeOf(vll.mType);
+						oins->mSTemp[1] = vll.mTemp;
+						oins->mTType = InterTypeOf(vll.mType);
+						oins->mTTemp = proc->AddTemporary(oins->mTType);
 
 						if (!vll.mType->IsNumericType())
 							mErrors->Error(exp->mLocation, "Left hand element type is not numeric");
@@ -746,47 +746,47 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 						switch (exp->mToken)
 						{
 						case TK_ASSIGN_ADD:
-							oins.mOperator = IA_ADD;
+							oins->mOperator = IA_ADD;
 							break;
 						case TK_ASSIGN_SUB:
-							oins.mOperator = IA_SUB;
+							oins->mOperator = IA_SUB;
 							break;
 						case TK_ASSIGN_MUL:
-							oins.mOperator = IA_MUL;
+							oins->mOperator = IA_MUL;
 							break;
 						case TK_ASSIGN_DIV:
 							if (vll.mType->mFlags & DTF_SIGNED)
-								oins.mOperator = IA_DIVS;
+								oins->mOperator = IA_DIVS;
 							else
-								oins.mOperator = IA_DIVU;
+								oins->mOperator = IA_DIVU;
 							break;
 						case TK_ASSIGN_MOD:
 							if (vll.mType->mFlags & DTF_SIGNED)
-								oins.mOperator = IA_MODS;
+								oins->mOperator = IA_MODS;
 							else
-								oins.mOperator = IA_MODU;
+								oins->mOperator = IA_MODU;
 							break;
 						case TK_ASSIGN_SHL:
-							oins.mOperator = IA_SHL;
+							oins->mOperator = IA_SHL;
 							break;
 						case TK_ASSIGN_SHR:
 							if (vll.mType->mFlags & DTF_SIGNED)
-								oins.mOperator = IA_SAR;
+								oins->mOperator = IA_SAR;
 							else
-								oins.mOperator = IA_SHR;
+								oins->mOperator = IA_SHR;
 							break;
 						case TK_ASSIGN_AND:
-							oins.mOperator = IA_AND;
+							oins->mOperator = IA_AND;
 							break;
 						case TK_ASSIGN_XOR:
-							oins.mOperator = IA_XOR;
+							oins->mOperator = IA_XOR;
 							break;
 						case TK_ASSIGN_OR:
-							oins.mOperator = IA_OR;
+							oins->mOperator = IA_OR;
 							break;
 						}
 
-						vr.mTemp = oins.mTTemp;
+						vr.mTemp = oins->mTTemp;
 						vr.mType = vll.mType;
 
 						block->Append(oins);
@@ -797,13 +797,13 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 					vr = CoerceType(proc, block, vr, vl.mType);
 				}
 
-				ins.mCode = IC_STORE;
-				ins.mMemory = IM_INDIRECT;
-				ins.mSType[0] = InterTypeOf(vr.mType);
-				ins.mSTemp[0] = vr.mTemp;
-				ins.mSType[1] = IT_POINTER;
-				ins.mSTemp[1] = vl.mTemp;
-				ins.mOperandSize = vl.mType->mSize;
+				ins->mCode = IC_STORE;
+				ins->mMemory = IM_INDIRECT;
+				ins->mSType[0] = InterTypeOf(vr.mType);
+				ins->mSTemp[0] = vr.mTemp;
+				ins->mSType[1] = IT_POINTER;
+				ins->mSTemp[1] = vl.mTemp;
+				ins->mOperandSize = vl.mType->mSize;
 				block->Append(ins);
 			}
 			}
@@ -826,36 +826,36 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 			vr = CoerceType(proc, block, vr, TheSignedIntTypeDeclaration);
 
-			InterInstruction	cins;
-			cins.mCode = IC_CONSTANT;
-			cins.mIntValue = vl.mType->mBase->mSize;
-			cins.mTType = IT_INT16;
-			cins.mTTemp = proc->AddTemporary(cins.mTType);
+			InterInstruction	*	cins = new InterInstruction();
+			cins->mCode = IC_CONSTANT;
+			cins->mIntValue = vl.mType->mBase->mSize;
+			cins->mTType = IT_INT16;
+			cins->mTTemp = proc->AddTemporary(cins->mTType);
 			block->Append(cins);
 
-			InterInstruction	mins;
-			mins.mCode = IC_BINARY_OPERATOR;
-			mins.mOperator = IA_MUL;
-			mins.mSType[0] = IT_INT16;
-			mins.mSTemp[0] = vr.mTemp;
-			mins.mSType[1] = IT_INT16;
-			mins.mSTemp[1] = cins.mTTemp;
-			mins.mTType = IT_INT16;
-			mins.mTTemp = proc->AddTemporary(mins.mTType);
+			InterInstruction	*	mins = new InterInstruction();
+			mins->mCode = IC_BINARY_OPERATOR;
+			mins->mOperator = IA_MUL;
+			mins->mSType[0] = IT_INT16;
+			mins->mSTemp[0] = vr.mTemp;
+			mins->mSType[1] = IT_INT16;
+			mins->mSTemp[1] = cins->mTTemp;
+			mins->mTType = IT_INT16;
+			mins->mTTemp = proc->AddTemporary(mins->mTType);
 			block->Append(mins);
 
-			InterInstruction	ains;
-			ains.mCode = IC_LEA;
-			ains.mMemory = IM_INDIRECT;
-			ains.mSType[0] = IT_INT16;
-			ains.mSTemp[0] = mins.mTTemp;
-			ains.mSType[1] = IT_POINTER;
-			ains.mSTemp[1] = vl.mTemp;
-			ains.mTType = IT_POINTER;
-			ains.mTTemp = proc->AddTemporary(ains.mTType);
+			InterInstruction	*	ains = new InterInstruction();
+			ains->mCode = IC_LEA;
+			ains->mMemory = IM_INDIRECT;
+			ains->mSType[0] = IT_INT16;
+			ains->mSTemp[0] = mins->mTTemp;
+			ains->mSType[1] = IT_POINTER;
+			ains->mSTemp[1] = vl.mTemp;
+			ains->mTType = IT_POINTER;
+			ains->mTTemp = proc->AddTemporary(ains->mTType);
 			block->Append(ains);
 
-			return ExValue(vl.mType->mBase, ains.mTTemp, 1);
+			return ExValue(vl.mType->mBase, ains->mTTemp, 1);
 		}
 
 		case EX_QUALIFY:
@@ -866,25 +866,25 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			if (vl.mReference != 1)
 				mErrors->Error(exp->mLocation, "Not an addressable expression");
 
-			InterInstruction	cins;
-			cins.mCode = IC_CONSTANT;
-			cins.mIntValue = exp->mDecValue->mOffset;
-			cins.mTType = IT_INT16;
-			cins.mTTemp = proc->AddTemporary(cins.mTType);
+			InterInstruction	*	cins = new InterInstruction();
+			cins->mCode = IC_CONSTANT;
+			cins->mIntValue = exp->mDecValue->mOffset;
+			cins->mTType = IT_INT16;
+			cins->mTTemp = proc->AddTemporary(cins->mTType);
 			block->Append(cins);
 
-			InterInstruction	ains;
-			ains.mCode = IC_LEA;
-			ains.mMemory = IM_INDIRECT;
-			ains.mSType[0] = IT_INT16;
-			ains.mSTemp[0] = cins.mTTemp;
-			ains.mSType[1] = IT_POINTER;
-			ains.mSTemp[1] = vl.mTemp;
-			ains.mTType = IT_POINTER;
-			ains.mTTemp = proc->AddTemporary(ains.mTType);
+			InterInstruction	*	ains = new InterInstruction();
+			ains->mCode = IC_LEA;
+			ains->mMemory = IM_INDIRECT;
+			ains->mSType[0] = IT_INT16;
+			ains->mSTemp[0] = cins->mTTemp;
+			ains->mSType[1] = IT_POINTER;
+			ains->mSTemp[1] = vl.mTemp;
+			ains->mTType = IT_POINTER;
+			ains->mTTemp = proc->AddTemporary(ains->mTType);
 			block->Append(ains);
 
-			return ExValue(exp->mDecValue->mBase, ains.mTTemp, 1);
+			return ExValue(exp->mDecValue->mBase, ains->mTTemp, 1);
 		}
 
 		case EX_BINARY:
@@ -893,7 +893,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			vr = TranslateExpression(procType, proc, block, exp->mRight, breakBlock, continueBlock);
 			vr = Dereference(proc, block, vr);
 
-			InterInstruction	ins;
+			InterInstruction	*	ins = new InterInstruction();
 
 			if (vl.mType->mType == DT_TYPE_POINTER || vl.mType->mType == DT_TYPE_ARRAY)
 			{
@@ -911,93 +911,93 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 				if (vr.mType->IsIntegerType())
 				{
-					InterInstruction	cins;
-					cins.mCode = IC_CONSTANT;
+					InterInstruction	*	cins = new InterInstruction();
+					cins->mCode = IC_CONSTANT;
 
 					if (exp->mToken == TK_ADD)
 					{
-						cins.mIntValue = vl.mType->mBase->mSize;
+						cins->mIntValue = vl.mType->mBase->mSize;
 					}
 					else if (exp->mToken == TK_SUB)
 					{
-						cins.mIntValue = -vl.mType->mBase->mSize;
+						cins->mIntValue = -vl.mType->mBase->mSize;
 					}
 					else
 						mErrors->Error(exp->mLocation, "Invalid pointer operation");
 
-					cins.mTType = IT_INT16;
-					cins.mTTemp = proc->AddTemporary(cins.mTType);
+					cins->mTType = IT_INT16;
+					cins->mTTemp = proc->AddTemporary(cins->mTType);
 					block->Append(cins);
 
-					InterInstruction	mins;
-					mins.mCode = IC_BINARY_OPERATOR;
-					mins.mOperator = IA_MUL;
-					mins.mSType[0] = IT_INT16;
-					mins.mSTemp[0] = vr.mTemp;
-					mins.mSType[1] = IT_INT16;
-					mins.mSTemp[1] = cins.mTTemp;
-					mins.mTType = IT_INT16;
-					mins.mTTemp = proc->AddTemporary(mins.mTType);
+					InterInstruction	*	mins = new InterInstruction();
+					mins->mCode = IC_BINARY_OPERATOR;
+					mins->mOperator = IA_MUL;
+					mins->mSType[0] = IT_INT16;
+					mins->mSTemp[0] = vr.mTemp;
+					mins->mSType[1] = IT_INT16;
+					mins->mSTemp[1] = cins->mTTemp;
+					mins->mTType = IT_INT16;
+					mins->mTTemp = proc->AddTemporary(mins->mTType);
 					block->Append(mins);
 
-					ins.mCode = IC_LEA;
-					ins.mMemory = IM_INDIRECT;
-					ins.mSType[0] = IT_INT16;
-					ins.mSTemp[0] = mins.mTTemp;
-					ins.mSType[1] = IT_POINTER;
-					ins.mSTemp[1] = vl.mTemp;
-					ins.mTType = IT_POINTER;
-					ins.mTTemp = proc->AddTemporary(ins.mTType);
+					ins->mCode = IC_LEA;
+					ins->mMemory = IM_INDIRECT;
+					ins->mSType[0] = IT_INT16;
+					ins->mSTemp[0] = mins->mTTemp;
+					ins->mSType[1] = IT_POINTER;
+					ins->mSTemp[1] = vl.mTemp;
+					ins->mTType = IT_POINTER;
+					ins->mTTemp = proc->AddTemporary(ins->mTType);
 					block->Append(ins);
 				}
 				else if (vr.mType->IsSame(vl.mType))
 				{
 					if (exp->mToken == TK_SUB)
 					{
-						InterInstruction	clins, crins;
-						clins.mCode = IC_TYPECAST;
-						clins.mSTemp[0] = vl.mTemp;
-						clins.mSType[0] = IT_POINTER;
-						clins.mTType = IT_INT16;
-						clins.mTTemp = proc->AddTemporary(clins.mTType);
+						InterInstruction	*	clins = new InterInstruction(), *	crins = new InterInstruction();
+						clins->mCode = IC_TYPECAST;
+						clins->mSTemp[0] = vl.mTemp;
+						clins->mSType[0] = IT_POINTER;
+						clins->mTType = IT_INT16;
+						clins->mTTemp = proc->AddTemporary(clins->mTType);
 						block->Append(clins);
 
-						crins.mCode = IC_TYPECAST;
-						crins.mSTemp[0] = vr.mTemp;
-						crins.mSType[0] = IT_POINTER;
-						crins.mTType = IT_INT16;
-						crins.mTTemp = proc->AddTemporary(crins.mTType);
+						crins->mCode = IC_TYPECAST;
+						crins->mSTemp[0] = vr.mTemp;
+						crins->mSType[0] = IT_POINTER;
+						crins->mTType = IT_INT16;
+						crins->mTTemp = proc->AddTemporary(crins->mTType);
 						block->Append(crins);
 
-						InterInstruction	cins;
-						cins.mCode = IC_CONSTANT;
-						cins.mIntValue = vl.mType->mBase->mSize;
-						cins.mTType = IT_INT16;
-						cins.mTTemp = proc->AddTemporary(cins.mTType);
+						InterInstruction	*	cins = new InterInstruction();
+						cins->mCode = IC_CONSTANT;
+						cins->mIntValue = vl.mType->mBase->mSize;
+						cins->mTType = IT_INT16;
+						cins->mTTemp = proc->AddTemporary(cins->mTType);
 						block->Append(cins);
 
-						InterInstruction	sins, dins;
-						sins.mCode = IC_BINARY_OPERATOR;
-						sins.mOperator = IA_SUB;
-						sins.mSType[0] = IT_INT16;
-						sins.mSTemp[0] = crins.mTTemp;
-						sins.mSType[1] = IT_INT16;
-						sins.mSTemp[1] = clins.mTTemp;
-						sins.mTType = IT_INT16;
-						sins.mTTemp = proc->AddTemporary(sins.mTType);
+						InterInstruction	*	sins = new InterInstruction(), *	dins = new InterInstruction();
+						sins->mCode = IC_BINARY_OPERATOR;
+						sins->mOperator = IA_SUB;
+						sins->mSType[0] = IT_INT16;
+						sins->mSTemp[0] = crins->mTTemp;
+						sins->mSType[1] = IT_INT16;
+						sins->mSTemp[1] = clins->mTTemp;
+						sins->mTType = IT_INT16;
+						sins->mTTemp = proc->AddTemporary(sins->mTType);
 						block->Append(sins);
 
-						dins.mCode = IC_BINARY_OPERATOR;
-						dins.mOperator = IA_DIVS;
-						dins.mSType[0] = IT_INT16;
-						dins.mSTemp[0] = cins.mTTemp;
-						dins.mSType[1] = IT_INT16;
-						dins.mSTemp[1] = sins.mTTemp;
-						dins.mTType = IT_INT16;
-						dins.mTTemp = proc->AddTemporary(dins.mTType);
+						dins->mCode = IC_BINARY_OPERATOR;
+						dins->mOperator = IA_DIVS;
+						dins->mSType[0] = IT_INT16;
+						dins->mSTemp[0] = cins->mTTemp;
+						dins->mSType[1] = IT_INT16;
+						dins->mSTemp[1] = sins->mTTemp;
+						dins->mTType = IT_INT16;
+						dins->mTTemp = proc->AddTemporary(dins->mTType);
 						block->Append(dins);
 
-						return ExValue(TheSignedIntTypeDeclaration, dins.mTTemp);
+						return ExValue(TheSignedIntTypeDeclaration, dins->mTTemp);
 					}
 					else
 						mErrors->Error(exp->mLocation, "Invalid pointer operation");
@@ -1029,51 +1029,51 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 				bool	signedOP = dtype->mFlags & DTF_SIGNED;
 
-				ins.mCode = IC_BINARY_OPERATOR;
+				ins->mCode = IC_BINARY_OPERATOR;
 				switch (exp->mToken)
 				{
 				case TK_ADD:
-					ins.mOperator = IA_ADD;
+					ins->mOperator = IA_ADD;
 					break;
 				case TK_SUB:
-					ins.mOperator = IA_SUB;
+					ins->mOperator = IA_SUB;
 					break;
 				case TK_MUL:
-					ins.mOperator = IA_MUL;
+					ins->mOperator = IA_MUL;
 					break;
 				case TK_DIV:
-					ins.mOperator = signedOP ? IA_DIVS : IA_DIVU;
+					ins->mOperator = signedOP ? IA_DIVS : IA_DIVU;
 					break;
 				case TK_MOD:
-					ins.mOperator = signedOP ? IA_MODS : IA_MODU;
+					ins->mOperator = signedOP ? IA_MODS : IA_MODU;
 					break;
 				case TK_LEFT_SHIFT:
-					ins.mOperator = IA_SHL;
+					ins->mOperator = IA_SHL;
 					break;
 				case TK_RIGHT_SHIFT:
-					ins.mOperator = (vl.mType->mFlags & DTF_SIGNED) ? IA_SAR : IA_SHR;
+					ins->mOperator = (vl.mType->mFlags & DTF_SIGNED) ? IA_SAR : IA_SHR;
 					break;
 				case TK_BINARY_AND:
-					ins.mOperator = IA_AND;
+					ins->mOperator = IA_AND;
 					break;
 				case TK_BINARY_OR:
-					ins.mOperator = IA_OR;
+					ins->mOperator = IA_OR;
 					break;
 				case TK_BINARY_XOR:
-					ins.mOperator = IA_XOR;
+					ins->mOperator = IA_XOR;
 					break;
 				}
 
-				ins.mSType[0] = InterTypeOf(vr.mType);;
-				ins.mSTemp[0] = vr.mTemp;
-				ins.mSType[1] = InterTypeOf(vl.mType);;
-				ins.mSTemp[1] = vl.mTemp;
-				ins.mTType = InterTypeOfArithmetic(ins.mSType[0], ins.mSType[1]);
-				ins.mTTemp = proc->AddTemporary(ins.mTType);
+				ins->mSType[0] = InterTypeOf(vr.mType);;
+				ins->mSTemp[0] = vr.mTemp;
+				ins->mSType[1] = InterTypeOf(vl.mType);;
+				ins->mSTemp[1] = vl.mTemp;
+				ins->mTType = InterTypeOfArithmetic(ins->mSType[0], ins->mSType[1]);
+				ins->mTTemp = proc->AddTemporary(ins->mTType);
 				block->Append(ins);
 			}
 
-			return ExValue(vl.mType, ins.mTTemp);
+			return ExValue(vl.mType, ins->mTTemp);
 		}
 
 
@@ -1088,44 +1088,44 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			if (vl.mType->mFlags & DTF_CONST)
 				mErrors->Error(exp->mLocation, "Cannot change const value");
 
-			InterInstruction	cins, ains, rins, sins;
+			InterInstruction	*	cins = new InterInstruction(), *	ains = new InterInstruction(), *	rins = new InterInstruction(), *	sins = new InterInstruction();
 
 			ExValue	vdl = Dereference(proc, block, vl);
 
 			bool	ftype = vl.mType->mType == DT_TYPE_FLOAT;
 
-			cins.mCode = IC_CONSTANT;
-			cins.mTType = ftype ? IT_FLOAT : IT_INT16;
-			cins.mTTemp = proc->AddTemporary(cins.mTType);
+			cins->mCode = IC_CONSTANT;
+			cins->mTType = ftype ? IT_FLOAT : IT_INT16;
+			cins->mTTemp = proc->AddTemporary(cins->mTType);
 			if (vdl.mType->mType == DT_TYPE_POINTER)
-				cins.mIntValue = exp->mToken == TK_INC ? vdl.mType->mBase->mSize : -(vdl.mType->mBase->mSize);
+				cins->mIntValue = exp->mToken == TK_INC ? vdl.mType->mBase->mSize : -(vdl.mType->mBase->mSize);
 			else if (vdl.mType->IsNumericType())
-				cins.mIntValue = exp->mToken == TK_INC ? 1 : -1;
+				cins->mIntValue = exp->mToken == TK_INC ? 1 : -1;
 			else
 				mErrors->Error(exp->mLocation, "Not a numeric value or pointer");
 
 			block->Append(cins);
 
-			ains.mCode = IC_BINARY_OPERATOR;
-			ains.mOperator = IA_ADD;
-			ains.mSType[0] = cins.mTType;
-			ains.mSTemp[0] = cins.mTTemp;
-			ains.mSType[1] = InterTypeOf(vdl.mType);
-			ains.mSTemp[1] = vdl.mTemp;
-			ains.mTType = ains.mSType[1];
-			ains.mTTemp = proc->AddTemporary(ains.mTType);
+			ains->mCode = IC_BINARY_OPERATOR;
+			ains->mOperator = IA_ADD;
+			ains->mSType[0] = cins->mTType;
+			ains->mSTemp[0] = cins->mTTemp;
+			ains->mSType[1] = InterTypeOf(vdl.mType);
+			ains->mSTemp[1] = vdl.mTemp;
+			ains->mTType = ains->mSType[1];
+			ains->mTTemp = proc->AddTemporary(ains->mTType);
 			block->Append(ains);
 
-			sins.mCode = IC_STORE;
-			sins.mMemory = IM_INDIRECT;
-			sins.mSType[0] = ains.mTType;
-			sins.mSTemp[0] = ains.mTTemp;
-			sins.mSType[1] = IT_POINTER;
-			sins.mSTemp[1] = vl.mTemp;
-			sins.mOperandSize = vl.mType->mSize;
+			sins->mCode = IC_STORE;
+			sins->mMemory = IM_INDIRECT;
+			sins->mSType[0] = ains->mTType;
+			sins->mSTemp[0] = ains->mTTemp;
+			sins->mSType[1] = IT_POINTER;
+			sins->mSTemp[1] = vl.mTemp;
+			sins->mOperandSize = vl.mType->mSize;
 			block->Append(sins);
 
-			return ExValue(vdl.mType, ains.mTTemp);
+			return ExValue(vdl.mType, ains->mTTemp);
 		}
 		break;
 
@@ -1140,40 +1140,40 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			if (vl.mType->mFlags & DTF_CONST)
 				mErrors->Error(exp->mLocation, "Cannot change const value");
 
-			InterInstruction	cins, ains, rins, sins;
+			InterInstruction	*	cins = new InterInstruction(), *	ains = new InterInstruction(), *	rins = new InterInstruction(), *	sins = new InterInstruction();
 
 			ExValue	vdl = Dereference(proc, block, vl);
 
 			bool	ftype = vl.mType->mType == DT_TYPE_FLOAT;
 
-			cins.mCode = IC_CONSTANT;
-			cins.mTType = ftype ? IT_FLOAT : IT_INT16;
-			cins.mTTemp = proc->AddTemporary(cins.mTType);
+			cins->mCode = IC_CONSTANT;
+			cins->mTType = ftype ? IT_FLOAT : IT_INT16;
+			cins->mTTemp = proc->AddTemporary(cins->mTType);
 			if (vdl.mType->mType == DT_TYPE_POINTER)
-				cins.mIntValue = exp->mToken == TK_INC ? vdl.mType->mBase->mSize : -(vdl.mType->mBase->mSize);
+				cins->mIntValue = exp->mToken == TK_INC ? vdl.mType->mBase->mSize : -(vdl.mType->mBase->mSize);
 			else if (vdl.mType->IsNumericType())
-				cins.mIntValue = exp->mToken == TK_INC ? 1 : -1;
+				cins->mIntValue = exp->mToken == TK_INC ? 1 : -1;
 			else
 				mErrors->Error(exp->mLocation, "Not a numeric value or pointer");
 			block->Append(cins);
 
-			ains.mCode = IC_BINARY_OPERATOR;
-			ains.mOperator = IA_ADD;
-			ains.mSType[0] = cins.mTType;
-			ains.mSTemp[0] = cins.mTTemp;
-			ains.mSType[1] = InterTypeOf(vdl.mType);
-			ains.mSTemp[1] = vdl.mTemp;
-			ains.mTType = ains.mSType[1];
-			ains.mTTemp = proc->AddTemporary(ains.mTType);
+			ains->mCode = IC_BINARY_OPERATOR;
+			ains->mOperator = IA_ADD;
+			ains->mSType[0] = cins->mTType;
+			ains->mSTemp[0] = cins->mTTemp;
+			ains->mSType[1] = InterTypeOf(vdl.mType);
+			ains->mSTemp[1] = vdl.mTemp;
+			ains->mTType = ains->mSType[1];
+			ains->mTTemp = proc->AddTemporary(ains->mTType);
 			block->Append(ains);
 
-			sins.mCode = IC_STORE;
-			sins.mMemory = IM_INDIRECT;
-			sins.mSType[0] = ains.mTType;
-			sins.mSTemp[0] = ains.mTTemp;
-			sins.mSType[1] = IT_POINTER;
-			sins.mSTemp[1] = vl.mTemp;
-			sins.mOperandSize = vl.mType->mSize;
+			sins->mCode = IC_STORE;
+			sins->mMemory = IM_INDIRECT;
+			sins->mSType[0] = ains->mTType;
+			sins->mSTemp[0] = ains->mTTemp;
+			sins->mSType[1] = IT_POINTER;
+			sins->mSTemp[1] = vl.mTemp;
+			sins->mOperandSize = vl.mType->mSize;
 			block->Append(sins);
 
 			return ExValue(vdl.mType, vdl.mTemp);
@@ -1184,27 +1184,27 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 		{	
 			vl = TranslateExpression(procType, proc, block, exp->mLeft, breakBlock, continueBlock);
 
-			InterInstruction	ins;
+			InterInstruction	*	ins = new InterInstruction();
 
-			ins.mCode = IC_UNARY_OPERATOR;
+			ins->mCode = IC_UNARY_OPERATOR;
 
 			switch (exp->mToken)
 			{
 			case TK_ADD:
 				vl = Dereference(proc, block, vl);
-				ins.mOperator = IA_NONE;
+				ins->mOperator = IA_NONE;
 				break;
 			case TK_SUB:
 				vl = Dereference(proc, block, vl);
 				if (!vl.mType->IsNumericType())
 					mErrors->Error(exp->mLocation, "Not a numeric type");
-				ins.mOperator = IA_NEG;
+				ins->mOperator = IA_NEG;
 				break;
 			case TK_BINARY_NOT:
 				vl = Dereference(proc, block, vl);
 				if (!(vl.mType->mType == DT_TYPE_POINTER || vl.mType->IsNumericType()))
 					mErrors->Error(exp->mLocation, "Not a numeric or pointer type");
-				ins.mOperator = IA_NOT;
+				ins->mOperator = IA_NOT;
 				break;
 			case TK_MUL:
 				if (vl.mType->mType != DT_TYPE_POINTER)
@@ -1223,14 +1223,14 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			}
 			}
 			
-			ins.mSType[0] = InterTypeOf(vl.mType);
-			ins.mSTemp[0] = vl.mTemp;
-			ins.mTType = ins.mSType[0];
-			ins.mTTemp = proc->AddTemporary(ins.mTType);
+			ins->mSType[0] = InterTypeOf(vl.mType);
+			ins->mSTemp[0] = vl.mTemp;
+			ins->mTType = ins->mSType[0];
+			ins->mTTemp = proc->AddTemporary(ins->mTType);
 
 			block->Append(ins);
 
-			return ExValue(vl.mType, ins.mTTemp);
+			return ExValue(vl.mType, ins->mTTemp);
 		}
 
 		case EX_RELATIONAL:
@@ -1240,7 +1240,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			vr = TranslateExpression(procType, proc, block, exp->mRight, breakBlock, continueBlock);
 			vr = Dereference(proc, block, vr);
 
-			InterInstruction	ins;
+			InterInstruction	*	ins = new InterInstruction();
 
 			Declaration* dtype = TheSignedIntTypeDeclaration;
 
@@ -1268,38 +1268,38 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 			bool	signedCompare = dtype->mFlags & DTF_SIGNED;
 
-			ins.mCode = IC_RELATIONAL_OPERATOR;
+			ins->mCode = IC_RELATIONAL_OPERATOR;
 			switch (exp->mToken)
 			{
 			case TK_EQUAL:
-				ins.mOperator = IA_CMPEQ;
+				ins->mOperator = IA_CMPEQ;
 				break;
 			case TK_NOT_EQUAL:
-				ins.mOperator = IA_CMPNE;
+				ins->mOperator = IA_CMPNE;
 				break;
 			case TK_GREATER_THAN:
-				ins.mOperator = signedCompare ? IA_CMPGS : IA_CMPGU;
+				ins->mOperator = signedCompare ? IA_CMPGS : IA_CMPGU;
 				break;
 			case TK_GREATER_EQUAL:
-				ins.mOperator = signedCompare ? IA_CMPGES : IA_CMPGEU;
+				ins->mOperator = signedCompare ? IA_CMPGES : IA_CMPGEU;
 				break;
 			case TK_LESS_THAN:
-				ins.mOperator = signedCompare ? IA_CMPLS : IA_CMPLU;
+				ins->mOperator = signedCompare ? IA_CMPLS : IA_CMPLU;
 				break;
 			case TK_LESS_EQUAL:
-				ins.mOperator = signedCompare ? IA_CMPLES : IA_CMPLEU;
+				ins->mOperator = signedCompare ? IA_CMPLES : IA_CMPLEU;
 				break;
 			}
-			ins.mSType[0] = InterTypeOf(vr.mType);;
-			ins.mSTemp[0] = vr.mTemp;
-			ins.mSType[1] = InterTypeOf(vl.mType);;
-			ins.mSTemp[1] = vl.mTemp;
-			ins.mTType = IT_BOOL;
-			ins.mTTemp = proc->AddTemporary(ins.mTType);
+			ins->mSType[0] = InterTypeOf(vr.mType);;
+			ins->mSTemp[0] = vr.mTemp;
+			ins->mSType[1] = InterTypeOf(vl.mType);;
+			ins->mSTemp[1] = vl.mTemp;
+			ins->mTType = IT_BOOL;
+			ins->mTTemp = proc->AddTemporary(ins->mTType);
 
 			block->Append(ins);
 
-			return ExValue(TheBoolTypeDeclaration, ins.mTTemp);
+			return ExValue(TheBoolTypeDeclaration, ins->mTTemp);
 		}
 
 		case EX_CALL:
@@ -1318,16 +1318,16 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 						mErrors->Error(exp->mLocation, "Cannot assign incompatible types");
 					vr = CoerceType(proc, block, vr, decf->mBase->mParams);
 
-					InterInstruction	ins;
-					ins.mCode = IC_UNARY_OPERATOR;
-					ins.mOperator = IA_ABS;
-					ins.mSType[0] = IT_FLOAT;
-					ins.mSTemp[0] = vr.mTemp;
-					ins.mTType = IT_FLOAT;
-					ins.mTTemp = proc->AddTemporary(ins.mTType);
+					InterInstruction	*	ins = new InterInstruction();
+					ins->mCode = IC_UNARY_OPERATOR;
+					ins->mOperator = IA_ABS;
+					ins->mSType[0] = IT_FLOAT;
+					ins->mSTemp[0] = vr.mTemp;
+					ins->mTType = IT_FLOAT;
+					ins->mTTemp = proc->AddTemporary(ins->mTType);
 					block->Append(ins);
 
-					return ExValue(TheFloatTypeDeclaration, ins.mTTemp);
+					return ExValue(TheFloatTypeDeclaration, ins->mTTemp);
 				}
 				else if (!strcmp(iname->mString, "floor"))
 				{
@@ -1338,16 +1338,16 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 						mErrors->Error(exp->mLocation, "Cannot assign incompatible types");
 					vr = CoerceType(proc, block, vr, decf->mBase->mParams);
 
-					InterInstruction	ins;
-					ins.mCode = IC_UNARY_OPERATOR;
-					ins.mOperator = IA_FLOOR;
-					ins.mSType[0] = IT_FLOAT;
-					ins.mSTemp[0] = vr.mTemp;
-					ins.mTType = IT_FLOAT;
-					ins.mTTemp = proc->AddTemporary(ins.mTType);
+					InterInstruction	*	ins = new InterInstruction();
+					ins->mCode = IC_UNARY_OPERATOR;
+					ins->mOperator = IA_FLOOR;
+					ins->mSType[0] = IT_FLOAT;
+					ins->mSTemp[0] = vr.mTemp;
+					ins->mTType = IT_FLOAT;
+					ins->mTTemp = proc->AddTemporary(ins->mTType);
 					block->Append(ins);
 
-					return ExValue(TheFloatTypeDeclaration, ins.mTTemp);
+					return ExValue(TheFloatTypeDeclaration, ins->mTTemp);
 				}
 				else if (!strcmp(iname->mString, "ceil"))
 				{
@@ -1358,16 +1358,16 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 						mErrors->Error(exp->mLocation, "Cannot assign incompatible types");
 					vr = CoerceType(proc, block, vr, decf->mBase->mParams);
 
-					InterInstruction	ins;
-					ins.mCode = IC_UNARY_OPERATOR;
-					ins.mOperator = IA_CEIL;
-					ins.mSType[0] = IT_FLOAT;
-					ins.mSTemp[0] = vr.mTemp;
-					ins.mTType = IT_FLOAT;
-					ins.mTTemp = proc->AddTemporary(ins.mTType);
+					InterInstruction	*	ins = new InterInstruction();
+					ins->mCode = IC_UNARY_OPERATOR;
+					ins->mOperator = IA_CEIL;
+					ins->mSType[0] = IT_FLOAT;
+					ins->mSTemp[0] = vr.mTemp;
+					ins->mTType = IT_FLOAT;
+					ins->mTTemp = proc->AddTemporary(ins->mTType);
 					block->Append(ins);
 
-					return ExValue(TheFloatTypeDeclaration, ins.mTTemp);
+					return ExValue(TheFloatTypeDeclaration, ins->mTTemp);
 				}
 				else
 					mErrors->Error(exp->mLeft->mDecValue->mLocation, "Unknown intrinsic function", iname->mString);
@@ -1384,9 +1384,9 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 				int	findex = block->mInstructions.Size();
 				InterCodeBasicBlock* fblock = block;
 
-				InterInstruction	fins;
-				fins.mCode = IC_PUSH_FRAME;
-				fins.mIntValue = atotal;
+				InterInstruction	*	fins = new InterInstruction();
+				fins->mCode = IC_PUSH_FRAME;
+				fins->mIntValue = atotal;
 				block->Append(fins);
 
 				Declaration	* ftype = vl.mType;
@@ -1397,22 +1397,22 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 				Expression* pex = exp->mRight;
 				while (pex)
 				{
-					InterInstruction	ains;
-					ains.mCode = IC_CONSTANT;
-					ains.mTType = IT_POINTER;
-					ains.mTTemp = proc->AddTemporary(ains.mTType);
-					ains.mMemory = IM_FRAME;
+					InterInstruction	*	ains = new InterInstruction();
+					ains->mCode = IC_CONSTANT;
+					ains->mTType = IT_POINTER;
+					ains->mTTemp = proc->AddTemporary(ains->mTType);
+					ains->mMemory = IM_FRAME;
 					if (pdec)
 					{
-						ains.mVarIndex = pdec->mVarIndex;
-						ains.mIntValue = pdec->mOffset;
-						ains.mOperandSize = pdec->mSize;
+						ains->mVarIndex = pdec->mVarIndex;
+						ains->mIntValue = pdec->mOffset;
+						ains->mOperandSize = pdec->mSize;
 					}
 					else if (ftype->mFlags & DTF_VARIADIC)
 					{
-						ains.mVarIndex = atotal;
-						ains.mIntValue = 0;
-						ains.mOperandSize = 2;
+						ains->mVarIndex = atotal;
+						ains->mIntValue = 0;
+						ains->mOperandSize = 2;
 					}
 					else
 					{
@@ -1449,23 +1449,23 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 						vr = CoerceType(proc, block, vr, TheSignedIntTypeDeclaration);
 					}
 
-					InterInstruction	wins;
-					wins.mCode = IC_STORE;
-					wins.mMemory = IM_INDIRECT;
-					wins.mSType[0] = InterTypeOf(vr.mType);;
-					wins.mSTemp[0] = vr.mTemp;
-					wins.mSType[1] = IT_POINTER;
-					wins.mSTemp[1] = ains.mTTemp;
+					InterInstruction	*	wins = new InterInstruction();
+					wins->mCode = IC_STORE;
+					wins->mMemory = IM_INDIRECT;
+					wins->mSType[0] = InterTypeOf(vr.mType);;
+					wins->mSTemp[0] = vr.mTemp;
+					wins->mSType[1] = IT_POINTER;
+					wins->mSTemp[1] = ains->mTTemp;
 					if (pdec)
-						wins.mOperandSize = pdec->mSize;
+						wins->mOperandSize = pdec->mSize;
 					else if (vr.mType->mSize > 2 && vr.mType->mType != DT_TYPE_ARRAY)
-						wins.mOperandSize = vr.mType->mSize;
+						wins->mOperandSize = vr.mType->mSize;
 					else
-						wins.mOperandSize = 2;
+						wins->mOperandSize = 2;
 
 					block->Append(wins);
 
-					atotal += wins.mOperandSize;
+					atotal += wins->mOperandSize;
 					if (pdec)
 						pdec = pdec->mNext;
 				}
@@ -1473,29 +1473,29 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 				if (pdec)
 					mErrors->Error(exp->mLocation, "Not enough arguments for function call");
 
-				InterInstruction	cins;
+				InterInstruction	*	cins = new InterInstruction();
 				if (exp->mLeft->mDecValue && exp->mLeft->mDecValue->mFlags & DTF_NATIVE)
-					cins.mCode = IC_JSR;
+					cins->mCode = IC_JSR;
 				else
-					cins.mCode = IC_CALL;
-				cins.mSType[0] = IT_POINTER;
-				cins.mSTemp[0] = vl.mTemp;
+					cins->mCode = IC_CALL;
+				cins->mSType[0] = IT_POINTER;
+				cins->mSTemp[0] = vl.mTemp;
 				if (ftype->mBase->mType != DT_TYPE_VOID)
 				{
-					cins.mTType = InterTypeOf(ftype->mBase);
-					cins.mTTemp = proc->AddTemporary(cins.mTType);
+					cins->mTType = InterTypeOf(ftype->mBase);
+					cins->mTTemp = proc->AddTemporary(cins->mTType);
 				}
 
 				block->Append(cins);
 
-				fblock->mInstructions[findex].mIntValue = atotal;
+				fblock->mInstructions[findex]->mIntValue = atotal;
 
-				InterInstruction	xins;
-				xins.mCode = IC_POP_FRAME;
-				xins.mIntValue = atotal;
+				InterInstruction	*	xins = new InterInstruction();
+				xins->mCode = IC_POP_FRAME;
+				xins->mIntValue = atotal;
 				block->Append(xins);
 
-				return ExValue(ftype->mBase, cins.mTTemp);
+				return ExValue(ftype->mBase, cins->mTTemp);
 			}
 
 		}
@@ -1510,12 +1510,12 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 				cexp = cexp->mRight;
 			}
 
-			InterInstruction	ins;
-			ins.mCode = IC_CONSTANT;
-			ins.mTType = IT_POINTER;
-			ins.mTTemp = proc->AddTemporary(ins.mTType);
-			ins.mOperandSize = osize;
-			ins.mIntValue = 0;
+			InterInstruction	*	ins = new InterInstruction();
+			ins->mCode = IC_CONSTANT;
+			ins->mTType = IT_POINTER;
+			ins->mTTemp = proc->AddTemporary(ins->mTType);
+			ins->mOperandSize = osize;
+			ins->mIntValue = 0;
 
 			InterVariable	var;
 			var.mOffset = 0;
@@ -1671,14 +1671,14 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 			if (block)
 			{
-				ins.mMemory = IM_GLOBAL;
-				ins.mVarIndex = var.mIndex;
+				ins->mMemory = IM_GLOBAL;
+				ins->mVarIndex = var.mIndex;
 				block->Append(ins);
 
-				InterInstruction	jins;
-				jins.mCode = IC_JSR;
-				jins.mSType[0] = IT_POINTER;
-				jins.mSTemp[0] = ins.mTTemp;
+				InterInstruction	*	jins = new InterInstruction();
+				jins->mCode = IC_JSR;
+				jins->mSType[0] = IT_POINTER;
+				jins->mSTemp[0] = ins->mTTemp;
 
 				block->Append(jins);
 			}
@@ -1688,7 +1688,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 		case EX_RETURN:
 		{
-			InterInstruction	ins;
+			InterInstruction	*	ins = new InterInstruction();
 			if (exp->mLeft)
 			{
 				vr = TranslateExpression(procType, proc, block, exp->mLeft, breakBlock, continueBlock);
@@ -1699,16 +1699,16 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 				else if (!procType->mBase->CanAssign(vr.mType))
 					mErrors->Error(exp->mLocation, "Cannot return incompatible type");
 
-				ins.mSType[0] = InterTypeOf(vr.mType);
-				ins.mSTemp[0] = vr.mTemp;
-				ins.mCode = IC_RETURN_VALUE;
+				ins->mSType[0] = InterTypeOf(vr.mType);
+				ins->mSTemp[0] = vr.mTemp;
+				ins->mCode = IC_RETURN_VALUE;
 			}
 			else
 			{
 				if (procType->mBase && procType->mBase->mType != DT_TYPE_VOID)
 					mErrors->Error(exp->mLocation, "Function has non void return type");
 
-				ins.mCode = IC_RETURN;
+				ins->mCode = IC_RETURN;
 			}
 
 			block->Append(ins);
@@ -1723,8 +1723,8 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 		{
 			if (breakBlock)
 			{
-				InterInstruction	jins;
-				jins.mCode = IC_JUMP;
+				InterInstruction	*	jins = new InterInstruction();
+				jins->mCode = IC_JUMP;
 				block->Append(jins);
 
 				block->Close(breakBlock, nullptr);
@@ -1741,8 +1741,8 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 		{
 			if (continueBlock)
 			{
-				InterInstruction	jins;
-				jins.mCode = IC_JUMP;
+				InterInstruction	*	jins = new InterInstruction();
+				jins->mCode = IC_JUMP;
 				block->Append(jins);
 
 				block->Close(continueBlock, nullptr);
@@ -1760,31 +1760,33 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			vl = TranslateExpression(procType, proc, block, exp->mLeft, breakBlock, continueBlock);
 			vl = Dereference(proc, block, vl);
 
-			InterInstruction	zins;
-			zins.mCode = IC_CONSTANT;
-			zins.mTType = InterTypeOf(vr.mType);
-			zins.mTTemp = proc->AddTemporary(zins.mTType);
-			zins.mIntValue = 0;
+			InterInstruction	*	zins = new InterInstruction();
+			zins->mCode = IC_CONSTANT;
+			zins->mTType = InterTypeOf(vr.mType);
+			zins->mTTemp = proc->AddTemporary(zins->mTType);
+			zins->mIntValue = 0;
 			block->Append(zins);
 
-			InterInstruction	ins;
-			ins.mCode = IC_RELATIONAL_OPERATOR;
-			ins.mOperator = IA_CMPNE;
-			ins.mSType[0] = InterTypeOf(vr.mType);
-			ins.mSTemp[0] = zins.mTTemp;
-			ins.mSType[1] = InterTypeOf(vr.mType);
-			ins.mSTemp[1] = vl.mTemp;
-			ins.mTType = IT_BOOL;
-			ins.mTTemp = proc->AddTemporary(ins.mTType);
+			InterInstruction	*	ins = new InterInstruction();
+			ins->mCode = IC_RELATIONAL_OPERATOR;
+			ins->mOperator = IA_CMPNE;
+			ins->mSType[0] = InterTypeOf(vr.mType);
+			ins->mSTemp[0] = zins->mTTemp;
+			ins->mSType[1] = InterTypeOf(vr.mType);
+			ins->mSTemp[1] = vl.mTemp;
+			ins->mTType = IT_BOOL;
+			ins->mTTemp = proc->AddTemporary(ins->mTType);
 			block->Append(ins);
 
-			return ExValue(TheBoolTypeDeclaration, ins.mTTemp);
+			return ExValue(TheBoolTypeDeclaration, ins->mTTemp);
 		}
 
 		case EX_CONDITIONAL:
 		{
-			InterInstruction	jins;
-			jins.mCode = IC_JUMP;
+			InterInstruction	*	jins0 = new InterInstruction();
+			jins0->mCode = IC_JUMP;
+			InterInstruction* jins1 = new InterInstruction();
+			jins1->mCode = IC_JUMP;
 
 			InterCodeBasicBlock* tblock = new InterCodeBasicBlock();
 			proc->Append(tblock);
@@ -1838,26 +1840,26 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 			ttemp = proc->AddTemporary(ttype);
 
-			InterInstruction	rins;
-			rins.mCode = IC_LOAD_TEMPORARY;
-			rins.mSType[0] = InterTypeOf(vr.mType);
-			rins.mSTemp[0] = vr.mTemp;
-			rins.mTType = ttype;
-			rins.mTTemp = ttemp;
+			InterInstruction	*	rins = new InterInstruction();
+			rins->mCode = IC_LOAD_TEMPORARY;
+			rins->mSType[0] = InterTypeOf(vr.mType);
+			rins->mSTemp[0] = vr.mTemp;
+			rins->mTType = ttype;
+			rins->mTTemp = ttemp;
 			fblock->Append(rins);
 
-			InterInstruction	lins;
-			lins.mCode = IC_LOAD_TEMPORARY;
-			lins.mSType[0] = InterTypeOf(vl.mType);
-			lins.mSTemp[0] = vl.mTemp;
-			lins.mTType = ttype;
-			lins.mTTemp = ttemp;
+			InterInstruction	*	lins = new InterInstruction();
+			lins->mCode = IC_LOAD_TEMPORARY;
+			lins->mSType[0] = InterTypeOf(vl.mType);
+			lins->mSTemp[0] = vl.mTemp;
+			lins->mTType = ttype;
+			lins->mTTemp = ttemp;
 			tblock->Append(lins);
 
-			tblock->Append(jins);
+			tblock->Append(jins0);
 			tblock->Close(eblock, nullptr);
 
-			fblock->Append(jins);
+			fblock->Append(jins1);
 			fblock->Close(eblock, nullptr);
 
 			block = eblock;
@@ -1871,28 +1873,28 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 		{
 			vr = TranslateExpression(procType, proc, block, exp->mRight, breakBlock, continueBlock);
 
-			InterInstruction	ins;
+			InterInstruction	*	ins = new InterInstruction();
 
 			if (exp->mLeft->mDecType->mType == DT_TYPE_FLOAT && vr.mType->IsIntegerType())
 			{
 				vr = Dereference(proc, block, vr);
-				ins.mCode = IC_CONVERSION_OPERATOR;
-				ins.mOperator = IA_INT2FLOAT;
-				ins.mSType[0] = InterTypeOf(vr.mType);
-				ins.mSTemp[0] = vr.mTemp;
-				ins.mTType = InterTypeOf(exp->mLeft->mDecType);
-				ins.mTTemp = proc->AddTemporary(ins.mTType);
+				ins->mCode = IC_CONVERSION_OPERATOR;
+				ins->mOperator = IA_INT2FLOAT;
+				ins->mSType[0] = InterTypeOf(vr.mType);
+				ins->mSTemp[0] = vr.mTemp;
+				ins->mTType = InterTypeOf(exp->mLeft->mDecType);
+				ins->mTTemp = proc->AddTemporary(ins->mTType);
 				block->Append(ins);
 			}
 			else if (exp->mLeft->mDecType->IsIntegerType() && vr.mType->mType == DT_TYPE_FLOAT)
 			{
 				vr = Dereference(proc, block, vr);
-				ins.mCode = IC_CONVERSION_OPERATOR;
-				ins.mOperator = IA_FLOAT2INT;
-				ins.mSType[0] = InterTypeOf(vr.mType);
-				ins.mSTemp[0] = vr.mTemp;
-				ins.mTType = InterTypeOf(exp->mLeft->mDecType);
-				ins.mTTemp = proc->AddTemporary(ins.mTType);
+				ins->mCode = IC_CONVERSION_OPERATOR;
+				ins->mOperator = IA_FLOAT2INT;
+				ins->mSType[0] = InterTypeOf(vr.mType);
+				ins->mSTemp[0] = vr.mTemp;
+				ins->mTType = InterTypeOf(exp->mLeft->mDecType);
+				ins->mTTemp = proc->AddTemporary(ins->mTType);
 				block->Append(ins);
 			}
 			else if (exp->mLeft->mDecType->mType == DT_TYPE_POINTER && vr.mType->mType == DT_TYPE_POINTER)
@@ -1908,15 +1910,15 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			else
 			{
 				vr = Dereference(proc, block, vr);
-				ins.mCode = IC_TYPECAST;
-				ins.mSType[0] = InterTypeOf(vr.mType);
-				ins.mSTemp[0] = vr.mTemp;
-				ins.mTType = InterTypeOf(exp->mLeft->mDecType);
-				ins.mTTemp = proc->AddTemporary(ins.mTType);
+				ins->mCode = IC_TYPECAST;
+				ins->mSType[0] = InterTypeOf(vr.mType);
+				ins->mSTemp[0] = vr.mTemp;
+				ins->mTType = InterTypeOf(exp->mLeft->mDecType);
+				ins->mTTemp = proc->AddTemporary(ins->mTType);
 				block->Append(ins);
 			}
 
-			return ExValue(exp->mLeft->mDecType, ins.mTTemp);
+			return ExValue(exp->mLeft->mDecType, ins->mTTemp);
 		}
 			break;
 
@@ -1926,8 +1928,10 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 		}
 		case EX_WHILE:
 		{
-			InterInstruction	jins;
-			jins.mCode = IC_JUMP;
+			InterInstruction	*	jins0 = new InterInstruction();
+			jins0->mCode = IC_JUMP;
+			InterInstruction* jins1 = new InterInstruction();
+			jins1->mCode = IC_JUMP;
 
 			InterCodeBasicBlock* cblock = new InterCodeBasicBlock();
 			InterCodeBasicBlock* lblock = cblock;
@@ -1937,13 +1941,13 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			InterCodeBasicBlock* eblock = new InterCodeBasicBlock();
 			proc->Append(eblock);
 			
-			block->Append(jins);
+			block->Append(jins0);
 			block->Close(cblock, nullptr);
 
 			TranslateLogic(procType, proc, cblock, bblock, eblock, exp->mLeft);
 
 			vr = TranslateExpression(procType, proc, bblock, exp->mRight, eblock, lblock);
-			bblock->Append(jins);
+			bblock->Append(jins1);
 			bblock->Close(lblock, nullptr);
 
 			block = eblock;
@@ -1953,8 +1957,10 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 		case EX_IF:
 		{
-			InterInstruction	jins;
-			jins.mCode = IC_JUMP;
+			InterInstruction	*	jins0 = new InterInstruction();
+			jins0->mCode = IC_JUMP;
+			InterInstruction* jins1 = new InterInstruction();
+			jins1->mCode = IC_JUMP;
 
 			InterCodeBasicBlock* tblock = new InterCodeBasicBlock();
 			proc->Append(tblock);
@@ -1966,12 +1972,12 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			TranslateLogic(procType, proc, block, tblock, fblock, exp->mLeft);
 
 			vr = TranslateExpression(procType, proc, tblock, exp->mRight->mLeft, breakBlock, continueBlock);
-			tblock->Append(jins);
+			tblock->Append(jins0);
 			tblock->Close(eblock, nullptr);
 
 			if (exp->mRight->mRight)
 				vr = TranslateExpression(procType, proc, fblock, exp->mRight->mRight, breakBlock, continueBlock);
-			fblock->Append(jins);
+			fblock->Append(jins1);
 			fblock->Close(eblock, nullptr);
 
 			block = eblock;
@@ -1985,8 +1991,14 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			if (exp->mLeft->mRight)
 				TranslateExpression(procType, proc, block, exp->mLeft->mRight, breakBlock, continueBlock);
 
-			InterInstruction	jins;
-			jins.mCode = IC_JUMP;
+			InterInstruction	*	jins0 = new InterInstruction();
+			jins0->mCode = IC_JUMP;
+			InterInstruction* jins1 = new InterInstruction();
+			jins1->mCode = IC_JUMP;
+			InterInstruction* jins2 = new InterInstruction();
+			jins2->mCode = IC_JUMP;
+			InterInstruction* jins3 = new InterInstruction();
+			jins3->mCode = IC_JUMP;
 
 			InterCodeBasicBlock* cblock = new InterCodeBasicBlock();
 			InterCodeBasicBlock* lblock = cblock;
@@ -1998,7 +2010,7 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 			InterCodeBasicBlock* eblock = new InterCodeBasicBlock();
 			proc->Append(eblock);
 
-			block->Append(jins);
+			block->Append(jins0);
 			block->Close(cblock, nullptr);
 
 			// condition
@@ -2006,20 +2018,20 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 				TranslateLogic(procType, proc, cblock, bblock, eblock, exp->mLeft->mLeft->mLeft);
 			else
 			{
-				cblock->Append(jins);
+				cblock->Append(jins1);
 				cblock->Close(bblock, nullptr);
 			}
 
 			vr = TranslateExpression(procType, proc, bblock, exp->mRight, eblock, iblock);
 
-			bblock->Append(jins);
+			bblock->Append(jins2);
 			bblock->Close(iblock, nullptr);
 
 			// increment
 			if (exp->mLeft->mLeft->mRight)
 				TranslateExpression(procType, proc, iblock, exp->mLeft->mLeft->mRight, breakBlock, continueBlock);
 
-			iblock->Append(jins);
+			iblock->Append(jins3);
 			iblock->Close(lblock, nullptr);
 
 			block = eblock;
@@ -2029,8 +2041,8 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 		case EX_DO:
 		{
-			InterInstruction	jins;
-			jins.mCode = IC_JUMP;
+			InterInstruction	*	jins = new InterInstruction();
+			jins->mCode = IC_JUMP;
 
 			InterCodeBasicBlock* cblock = new InterCodeBasicBlock();
 			InterCodeBasicBlock* lblock = cblock;
@@ -2052,9 +2064,6 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 		case EX_SWITCH:
 		{
-			InterInstruction	jins;
-			jins.mCode = IC_JUMP;
-
 			vl = TranslateExpression(procType, proc, block, exp->mLeft, breakBlock, continueBlock);
 			vl = Dereference(proc, block, vl);
 
@@ -2081,28 +2090,31 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 					vr = TranslateExpression(procType, proc, sblock, cexp->mLeft, breakBlock, continueBlock);
 					vr = Dereference(proc, sblock, vr);
 
-					InterInstruction	cins;
-					cins.mCode = IC_RELATIONAL_OPERATOR;
-					cins.mOperator = IA_CMPEQ;
-					cins.mSType[0] = InterTypeOf(vr.mType);;
-					cins.mSTemp[0] = vr.mTemp;
-					cins.mSType[1] = InterTypeOf(vl.mType);;
-					cins.mSTemp[1] = vl.mTemp;
-					cins.mTType = IT_BOOL;
-					cins.mTTemp = proc->AddTemporary(cins.mTType);
+					InterInstruction	*	cins = new InterInstruction();
+					cins->mCode = IC_RELATIONAL_OPERATOR;
+					cins->mOperator = IA_CMPEQ;
+					cins->mSType[0] = InterTypeOf(vr.mType);;
+					cins->mSTemp[0] = vr.mTemp;
+					cins->mSType[1] = InterTypeOf(vl.mType);;
+					cins->mSTemp[1] = vl.mTemp;
+					cins->mTType = IT_BOOL;
+					cins->mTTemp = proc->AddTemporary(cins->mTType);
 
 					sblock->Append(cins);
 
-					InterInstruction	bins;
-					bins.mCode = IC_BRANCH;
-					bins.mSType[0] = IT_BOOL;
-					bins.mSTemp[0] = cins.mTTemp;
+					InterInstruction	*	bins = new InterInstruction();
+					bins->mCode = IC_BRANCH;
+					bins->mSType[0] = IT_BOOL;
+					bins->mSTemp[0] = cins->mTTemp;
 					sblock->Append(bins);
 
 					sblock->Close(nblock, cblock);
 
 					if (block)
 					{
+						InterInstruction* jins = new InterInstruction();
+						jins->mCode = IC_JUMP;
+
 						block->Append(jins);
 						block->Close(nblock, nullptr);
 					}
@@ -2119,6 +2131,9 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 						if (block)
 						{
+							InterInstruction* jins = new InterInstruction();
+							jins->mCode = IC_JUMP;
+
 							block->Append(jins);
 							block->Close(dblock, nullptr);
 						}
@@ -2135,6 +2150,9 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 				sexp = sexp->mRight;
 			}
 
+			InterInstruction* jins = new InterInstruction();
+			jins->mCode = IC_JUMP;
+
 			sblock->Append(jins);
 			if (dblock)
 				sblock->Close(dblock, nullptr);
@@ -2143,6 +2161,9 @@ InterCodeGenerator::ExValue InterCodeGenerator::TranslateExpression(Declaration*
 
 			if (block)
 			{
+				InterInstruction* jins = new InterInstruction();
+				jins->mCode = IC_JUMP;
+
 				block->Append(jins);
 				block->Close(eblock, nullptr);
 			}
@@ -2278,10 +2299,10 @@ void InterCodeGenerator::TranslateLogic(Declaration* procType, InterCodeProcedur
 		ExValue	vr = TranslateExpression(procType, proc, block, exp, nullptr, nullptr);
 		vr = Dereference(proc, block, vr);
 
-		InterInstruction	ins;
-		ins.mCode = IC_BRANCH;
-		ins.mSType[0] = InterTypeOf(vr.mType);
-		ins.mSTemp[0] = vr.mTemp;
+		InterInstruction	*	ins = new InterInstruction();
+		ins->mCode = IC_BRANCH;
+		ins->mSType[0] = InterTypeOf(vr.mType);
+		ins->mSTemp[0] = vr.mTemp;
 		block->Append(ins);
 
 		block->Close(tblock, fblock);
@@ -2312,8 +2333,8 @@ InterCodeProcedure* InterCodeGenerator::TranslateProcedure(InterCodeModule * mod
 	else
 		mErrors->Error(dec->mLocation, "Calling undefined function", dec->mIdent->mString);
 
-	InterInstruction	ins;
-	ins.mCode = IC_RETURN;
+	InterInstruction	*	ins = new InterInstruction();
+	ins->mCode = IC_RETURN;
 	exitBlock->Append(ins);
 	exitBlock->Close(nullptr, nullptr);
 
diff --git a/oscar64/NativeCodeGenerator.cpp b/oscar64/NativeCodeGenerator.cpp
index 46e3a3dc..07a2dd1e 100644
--- a/oscar64/NativeCodeGenerator.cpp
+++ b/oscar64/NativeCodeGenerator.cpp
@@ -1303,12 +1303,12 @@ int NativeCodeBasicBlock::PutBranch(NativeCodeProcedure* proc, AsmInsType code,
 	}
 }
 
-void NativeCodeBasicBlock::LoadConstantToReg(InterCodeProcedure * proc, const InterInstruction & ins, InterType type, int reg)
+void NativeCodeBasicBlock::LoadConstantToReg(InterCodeProcedure * proc, const InterInstruction * ins, InterType type, int reg)
 {
 	if (type == IT_FLOAT)
 	{
 		union { float f; unsigned int v; } cc;
-		cc.f = ins.mFloatValue;
+		cc.f = ins->mFloatValue;
 
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, cc.v & 0xff));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
@@ -1321,28 +1321,28 @@ void NativeCodeBasicBlock::LoadConstantToReg(InterCodeProcedure * proc, const In
 	}
 	else if (type == IT_POINTER)
 	{
-		if (ins.mMemory == IM_GLOBAL)
+		if (ins->mMemory == IM_GLOBAL)
 		{
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins.mIntValue, ins.mVarIndex, true, false));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins->mIntValue, ins->mVarIndex, true, false));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins.mIntValue, ins.mVarIndex, false, true));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins->mIntValue, ins->mVarIndex, false, true));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 		}
-		else if (ins.mMemory == IM_ABSOLUTE)
+		else if (ins->mMemory == IM_ABSOLUTE)
 		{
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mIntValue & 0xff));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mIntValue & 0xff));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mIntValue >> 8) & 0xff));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mIntValue >> 8) & 0xff));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 		}
-		else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+		else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 		{
-			int	index = ins.mIntValue;
+			int	index = ins->mIntValue;
 			int areg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-			if (ins.mMemory == IM_LOCAL)
-				index += proc->mLocalVars[ins.mVarIndex].mOffset;
+			if (ins->mMemory == IM_LOCAL)
+				index += proc->mLocalVars[ins->mVarIndex].mOffset;
 			else
-				index += ins.mVarIndex + proc->mLocalSize + 2;
+				index += ins->mVarIndex + proc->mLocalSize + 2;
 			CheckFrameIndex(areg, index, 2);
 
 			if (index != 0)
@@ -1356,12 +1356,12 @@ void NativeCodeBasicBlock::LoadConstantToReg(InterCodeProcedure * proc, const In
 				mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_IMMEDIATE, (index >> 8) & 0xff));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 		}
-		else if (ins.mMemory == IM_PROCEDURE)
+		else if (ins->mMemory == IM_PROCEDURE)
 		{
-			NativeCodeInstruction	lins(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins.mSIntConst[0], ins.mVarIndex, true, false);
-			lins.mFunction = ins.mMemory == IM_PROCEDURE;
-			NativeCodeInstruction	hins(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins.mSIntConst[0], ins.mVarIndex, false, true);
-			hins.mFunction = ins.mMemory == IM_PROCEDURE;
+			NativeCodeInstruction	lins(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins->mSIntConst[0], ins->mVarIndex, true, false);
+			lins.mFunction = ins->mMemory == IM_PROCEDURE;
+			NativeCodeInstruction	hins(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins->mSIntConst[0], ins->mVarIndex, false, true);
+			hins.mFunction = ins->mMemory == IM_PROCEDURE;
 
 			mIns.Push(lins);
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
@@ -1371,20 +1371,20 @@ void NativeCodeBasicBlock::LoadConstantToReg(InterCodeProcedure * proc, const In
 	}
 	else
 	{
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mIntValue & 0xff));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mIntValue & 0xff));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
-		if (InterTypeSize[ins.mTType] > 1)
+		if (InterTypeSize[ins->mTType] > 1)
 		{
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mIntValue >> 8) & 0xff));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mIntValue >> 8) & 0xff));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 		}
 	}
 
 }
 
-void NativeCodeBasicBlock::LoadConstant(InterCodeProcedure* proc, const InterInstruction& ins)
+void NativeCodeBasicBlock::LoadConstant(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	LoadConstantToReg(proc, ins, ins.mTType, BC_REG_TMP + proc->mTempOffset[ins.mTTemp]);
+	LoadConstantToReg(proc, ins, ins->mTType, BC_REG_TMP + proc->mTempOffset[ins->mTTemp]);
 }
 
 void NativeCodeBasicBlock::CheckFrameIndex(int& reg, int& index, int size)
@@ -1403,47 +1403,47 @@ void NativeCodeBasicBlock::CheckFrameIndex(int& reg, int& index, int size)
 	}
 }
 
-void NativeCodeBasicBlock::StoreValue(InterCodeProcedure* proc, const InterInstruction& ins)
+void NativeCodeBasicBlock::StoreValue(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	if (ins.mSType[0] == IT_FLOAT)
+	if (ins->mSType[0] == IT_FLOAT)
 	{
-		if (ins.mSTemp[1] < 0)
+		if (ins->mSTemp[1] < 0)
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
 				union { float f; unsigned int v; } cc;
-				cc.f = ins.mSFloatConst[0];
+				cc.f = ins->mSFloatConst[0];
 
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, cc.v & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1], ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1], ins->mVarIndex));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (cc.v >> 8) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1, ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1, ins->mVarIndex));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (cc.v >> 16) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 2, ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 2, ins->mVarIndex));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (cc.v >> 24) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 3, ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 3, ins->mVarIndex));
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, cc.v & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1]));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (cc.v >> 8) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (cc.v >> 16) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 2));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 2));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (cc.v >> 24) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 3));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 3));
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[1];
+					int	index = ins->mSIntConst[1];
 					int	reg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 					CheckFrameIndex(reg, index, 4);
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
@@ -1459,9 +1459,9 @@ void NativeCodeBasicBlock::StoreValue(InterCodeProcedure* proc, const InterInstr
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (cc.v >> 24) & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 				}
-				else if (ins.mMemory == IM_FRAME)
+				else if (ins->mMemory == IM_FRAME)
 				{
-					int	index = ins.mVarIndex + ins.mSIntConst[1] + 2;
+					int	index = ins->mVarIndex + ins->mSIntConst[1] + 2;
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, cc.v & 0xff));
@@ -1479,45 +1479,45 @@ void NativeCodeBasicBlock::StoreValue(InterCodeProcedure* proc, const InterInstr
 			}
 			else
 			{
-				int	sreg = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
+				int	sreg = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
 
-				if (ins.mSFinal[0] && CheckPredAccuStore(sreg))
+				if (ins->mSFinal[0] && CheckPredAccuStore(sreg))
 				{
 					// cull previous store from accu to temp using direcrt forwarding from accu
 					mIns.SetSize(mIns.Size() - 8);
 					sreg = BC_REG_ACCU;
 				}
 
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, sreg));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1], ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1], ins->mVarIndex));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, sreg + 1));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1, ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1, ins->mVarIndex));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, sreg + 2));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 2, ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 2, ins->mVarIndex));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, sreg + 3));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 3, ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 3, ins->mVarIndex));
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, sreg));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1]));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, sreg + 1));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, sreg + 2));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 2));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 2));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, sreg + 3));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 3));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 3));
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[1];
+					int	index = ins->mSIntConst[1];
 					int	reg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 					CheckFrameIndex(reg, index, 4);
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
@@ -1533,9 +1533,9 @@ void NativeCodeBasicBlock::StoreValue(InterCodeProcedure* proc, const InterInstr
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, sreg + 3));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 				}
-				else if (ins.mMemory == IM_FRAME)
+				else if (ins->mMemory == IM_FRAME)
 				{
-					int	index = ins.mVarIndex + ins.mSIntConst[1] + 2;
+					int	index = ins->mVarIndex + ins->mSIntConst[1] + 2;
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, sreg));
@@ -1554,334 +1554,334 @@ void NativeCodeBasicBlock::StoreValue(InterCodeProcedure* proc, const InterInstr
 		}
 		else
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins.mSIntConst[1]));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins->mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 16) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 16) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 24) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 24) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 				}
 			}
 			else
 			{
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins.mSIntConst[1]));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins->mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 2));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 2));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 3));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 3));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 				}
 			}
 		}
 	}
-	else if (ins.mSType[0] == IT_POINTER)
+	else if (ins->mSType[0] == IT_POINTER)
 	{
-		if (ins.mSTemp[1] < 0)
+		if (ins->mSTemp[1] < 0)
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1], ins.mVarIndex));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1, ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1], ins->mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1, ins->mVarIndex));
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1]));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1));
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[1];
+					int	index = ins->mSIntConst[1];
 					int	reg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 					CheckFrameIndex(reg, index, 2);
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 				}
-				else if (ins.mMemory == IM_FRAME)
+				else if (ins->mMemory == IM_FRAME)
 				{
-					int	index = ins.mVarIndex + ins.mSIntConst[1] + 2;
+					int	index = ins->mVarIndex + ins->mSIntConst[1] + 2;
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
 				}
 			}
 			else
 			{
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1], ins.mVarIndex));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1, ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1], ins->mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1, ins->mVarIndex));
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1]));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1));
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[1];
+					int	index = ins->mSIntConst[1];
 					int	reg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 					CheckFrameIndex(reg, index, 2);
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 				}
-				else if (ins.mMemory == IM_FRAME)
+				else if (ins->mMemory == IM_FRAME)
 				{
-					int	index = ins.mVarIndex + ins.mSIntConst[1] + 2;
+					int	index = ins->mVarIndex + ins->mSIntConst[1] + 2;
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
 				}
 			}
 		}
 		else
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins.mSIntConst[1]));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins->mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 				}
 			}
 			else
 			{
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins.mSIntConst[1]));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins->mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 				}
 			}
 		}
 	}
 	else
 	{
-		if (ins.mSTemp[1] < 0)
+		if (ins->mSTemp[1] < 0)
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mOperandSize == 1)
+				if (ins->mOperandSize == 1)
 				{
-					if (ins.mMemory == IM_GLOBAL)
+					if (ins->mMemory == IM_GLOBAL)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1], ins.mVarIndex));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1], ins->mVarIndex));
 					}
-					else if (ins.mMemory == IM_ABSOLUTE)
+					else if (ins->mMemory == IM_ABSOLUTE)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1]));
 					}
-					else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+					else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 					{
-						int	index = ins.mSIntConst[1];
+						int	index = ins->mSIntConst[1];
 						int	reg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-						if (ins.mMemory == IM_LOCAL)
-							index += proc->mLocalVars[ins.mVarIndex].mOffset;
+						if (ins->mMemory == IM_LOCAL)
+							index += proc->mLocalVars[ins->mVarIndex].mOffset;
 						else
-							index += ins.mVarIndex + proc->mLocalSize + 2;
+							index += ins->mVarIndex + proc->mLocalSize + 2;
 						CheckFrameIndex(reg, index, 1);
 
 						mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 					}
-					else if (ins.mMemory == IM_FRAME)
+					else if (ins->mMemory == IM_FRAME)
 					{
-						int	index = ins.mVarIndex + ins.mSIntConst[1] + 2;
+						int	index = ins->mVarIndex + ins->mSIntConst[1] + 2;
 
 						mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
 					}
 				}
-				else if (ins.mOperandSize == 2)
+				else if (ins->mOperandSize == 2)
 				{
-					if (ins.mMemory == IM_GLOBAL)
+					if (ins->mMemory == IM_GLOBAL)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1], ins.mVarIndex));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1, ins.mVarIndex));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1], ins->mVarIndex));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1, ins->mVarIndex));
 					}
-					else if (ins.mMemory == IM_ABSOLUTE)
+					else if (ins->mMemory == IM_ABSOLUTE)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1]));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1));
 					}
-					else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+					else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 					{
-						int	index = ins.mSIntConst[1];
+						int	index = ins->mSIntConst[1];
 						int	reg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-						if (ins.mMemory == IM_LOCAL)
-							index += proc->mLocalVars[ins.mVarIndex].mOffset;
+						if (ins->mMemory == IM_LOCAL)
+							index += proc->mLocalVars[ins->mVarIndex].mOffset;
 						else
-							index += ins.mVarIndex + proc->mLocalSize + 2;
+							index += ins->mVarIndex + proc->mLocalSize + 2;
 						CheckFrameIndex(reg, index, 2);
 
 						mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 						mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 					}
-					else if (ins.mMemory == IM_FRAME)
+					else if (ins->mMemory == IM_FRAME)
 					{
-						int	index = ins.mVarIndex + ins.mSIntConst[1] + 2;
+						int	index = ins->mVarIndex + ins->mSIntConst[1] + 2;
 
 						mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
 						mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
 					}
 				}
 			}
 			else
 			{
-				if (ins.mOperandSize == 1)
+				if (ins->mOperandSize == 1)
 				{
-					if (ins.mMemory == IM_GLOBAL)
+					if (ins->mMemory == IM_GLOBAL)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1], ins.mVarIndex));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1], ins->mVarIndex));
 					}
-					else if (ins.mMemory == IM_ABSOLUTE)
+					else if (ins->mMemory == IM_ABSOLUTE)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1]));
 					}
-					else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+					else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 					{
-						int	index = ins.mSIntConst[1];
+						int	index = ins->mSIntConst[1];
 						int	reg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-						if (ins.mMemory == IM_LOCAL)
-							index += proc->mLocalVars[ins.mVarIndex].mOffset;
+						if (ins->mMemory == IM_LOCAL)
+							index += proc->mLocalVars[ins->mVarIndex].mOffset;
 						else
-							index += ins.mVarIndex + proc->mLocalSize + 2;
+							index += ins->mVarIndex + proc->mLocalSize + 2;
 						CheckFrameIndex(reg, index, 1);
 
 						mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 					}
-					else if (ins.mMemory == IM_FRAME)
+					else if (ins->mMemory == IM_FRAME)
 					{
-						int	index = ins.mVarIndex + ins.mSIntConst[1] + 2;
+						int	index = ins->mVarIndex + ins->mSIntConst[1] + 2;
 
 						mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
 					}
 				}
-				else if (ins.mOperandSize == 2)
+				else if (ins->mOperandSize == 2)
 				{
-					if (ins.mMemory == IM_GLOBAL)
+					if (ins->mMemory == IM_GLOBAL)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1], ins.mVarIndex));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1, ins.mVarIndex));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1], ins->mVarIndex));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1, ins->mVarIndex));
 					}
-					else if (ins.mMemory == IM_ABSOLUTE)
+					else if (ins->mMemory == IM_ABSOLUTE)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1]));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins.mSIntConst[1] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, ins->mSIntConst[1] + 1));
 					}
-					else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+					else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 					{
-						int	index = ins.mSIntConst[1];
+						int	index = ins->mSIntConst[1];
 						int	reg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
 
-						if (ins.mMemory == IM_LOCAL)
-							index += proc->mLocalVars[ins.mVarIndex].mOffset;
+						if (ins->mMemory == IM_LOCAL)
+							index += proc->mLocalVars[ins->mVarIndex].mOffset;
 						else
-							index += ins.mVarIndex + proc->mLocalSize + 2;
+							index += ins->mVarIndex + proc->mLocalSize + 2;
 						CheckFrameIndex(reg, index, 2);
 
 						mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 						mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, reg));
 					}
-					else if (ins.mMemory == IM_FRAME)
+					else if (ins->mMemory == IM_FRAME)
 					{
-						int	index = ins.mVarIndex + ins.mSIntConst[1] + 2;
+						int	index = ins->mVarIndex + ins->mSIntConst[1] + 2;
 
 						mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
 						mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
 					}
 				}
@@ -1889,37 +1889,37 @@ void NativeCodeBasicBlock::StoreValue(InterCodeProcedure* proc, const InterInstr
 		}
 		else
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins.mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins->mSIntConst[1]));
 
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 
-					if (ins.mOperandSize == 2)
+					if (ins->mOperandSize == 2)
 					{
 						mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					}
 				}
 			}
 			else
 			{
-				if (ins.mMemory == IM_INDIRECT)
+				if (ins->mMemory == IM_INDIRECT)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins.mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins->mSIntConst[1]));
 
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 
-					if (ins.mOperandSize == 2)
+					if (ins->mOperandSize == 2)
 					{
 						mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
-						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					}
 				}
 			}
@@ -1928,38 +1928,38 @@ void NativeCodeBasicBlock::StoreValue(InterCodeProcedure* proc, const InterInstr
 
 }
 
-void NativeCodeBasicBlock::LoadStoreValue(InterCodeProcedure* proc, const InterInstruction& rins, const InterInstruction& wins)
+void NativeCodeBasicBlock::LoadStoreValue(InterCodeProcedure* proc, const InterInstruction * rins, const InterInstruction * wins)
 {
-	if (rins.mTType == IT_FLOAT)
+	if (rins->mTType == IT_FLOAT)
 	{
 
 	}
-	else if (rins.mTType == IT_POINTER)
+	else if (rins->mTType == IT_POINTER)
 	{
 
 	}
 	else
 	{
-		if (wins.mOperandSize == 1)
+		if (wins->mOperandSize == 1)
 		{
-			if (rins.mSTemp[0] < 0)
+			if (rins->mSTemp[0] < 0)
 			{
-				if (rins.mMemory == IM_GLOBAL)
+				if (rins->mMemory == IM_GLOBAL)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, rins.mSIntConst[0], rins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, rins->mSIntConst[0], rins->mVarIndex));
 				}
-				else if (rins.mMemory == IM_ABSOLUTE)
+				else if (rins->mMemory == IM_ABSOLUTE)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, rins.mSIntConst[0]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, rins->mSIntConst[0]));
 				}
-				else if (rins.mMemory == IM_LOCAL || rins.mMemory == IM_PARAM)
+				else if (rins->mMemory == IM_LOCAL || rins->mMemory == IM_PARAM)
 				{
-					int	index = rins.mSIntConst[0];
+					int	index = rins->mSIntConst[0];
 					int areg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-					if (rins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[rins.mVarIndex].mOffset;
+					if (rins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[rins->mVarIndex].mOffset;
 					else
-						index += rins.mVarIndex + proc->mLocalSize + 2;
+						index += rins->mVarIndex + proc->mLocalSize + 2;
 					CheckFrameIndex(areg, index, 4);
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
@@ -1968,39 +1968,39 @@ void NativeCodeBasicBlock::LoadStoreValue(InterCodeProcedure* proc, const InterI
 			}
 			else
 			{
-				if (rins.mMemory == IM_INDIRECT)
+				if (rins->mMemory == IM_INDIRECT)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, rins.mSIntConst[0]));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[rins.mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, rins->mSIntConst[0]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[rins->mSTemp[0]]));
 				}
 			}
 
-			if (wins.mSTemp[1] < 0)
+			if (wins->mSTemp[1] < 0)
 			{
-				if (wins.mMemory == IM_GLOBAL)
+				if (wins->mMemory == IM_GLOBAL)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, wins.mSIntConst[1], wins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, wins->mSIntConst[1], wins->mVarIndex));
 				}
-				else if (wins.mMemory == IM_ABSOLUTE)
+				else if (wins->mMemory == IM_ABSOLUTE)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, wins.mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ABSOLUTE, wins->mSIntConst[1]));
 				}
-				else if (wins.mMemory == IM_LOCAL || wins.mMemory == IM_PARAM)
+				else if (wins->mMemory == IM_LOCAL || wins->mMemory == IM_PARAM)
 				{
-					int	index = wins.mSIntConst[1];
+					int	index = wins->mSIntConst[1];
 					int areg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-					if (wins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[wins.mVarIndex].mOffset;
+					if (wins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[wins->mVarIndex].mOffset;
 					else
-						index += wins.mVarIndex + proc->mLocalSize + 2;
+						index += wins->mVarIndex + proc->mLocalSize + 2;
 					CheckFrameIndex(areg, index, 1);
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, areg));
 				}
-				else if (wins.mMemory == IM_FRAME)
+				else if (wins->mMemory == IM_FRAME)
 				{
-					int	index = wins.mVarIndex + wins.mSIntConst[1] + 2;
+					int	index = wins->mVarIndex + wins->mSIntConst[1] + 2;
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_STACK));
@@ -2008,52 +2008,52 @@ void NativeCodeBasicBlock::LoadStoreValue(InterCodeProcedure* proc, const InterI
 			}
 			else
 			{
-				if (wins.mMemory == IM_INDIRECT)
+				if (wins->mMemory == IM_INDIRECT)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, wins.mSIntConst[1]));
-					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[wins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, wins->mSIntConst[1]));
+					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[wins->mSTemp[1]]));
 				}
 			}
 		}
 	}
 }
 
-void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterInstruction& ins, int reg, const NativeCodeInstruction* ainsl, const NativeCodeInstruction* ainsh)
+void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterInstruction * ins, int reg, const NativeCodeInstruction* ainsl, const NativeCodeInstruction* ainsh)
 {
-	if (ins.mTType == IT_FLOAT)
+	if (ins->mTType == IT_FLOAT)
 	{
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{
-			if (ins.mMemory == IM_GLOBAL)
+			if (ins->mMemory == IM_GLOBAL)
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0], ins.mVarIndex));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0], ins->mVarIndex));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0] + 1, ins.mVarIndex));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0] + 1, ins->mVarIndex));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0] + 2, ins.mVarIndex));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0] + 2, ins->mVarIndex));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 2));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0] + 3, ins.mVarIndex));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0] + 3, ins->mVarIndex));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 3));
 			}
-			else if (ins.mMemory == IM_ABSOLUTE)
+			else if (ins->mMemory == IM_ABSOLUTE)
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0]));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0] + 1));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0] + 1));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0] + 2));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0] + 2));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 2));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0] + 3));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0] + 3));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 3));
 			}
-			else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+			else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 			{
-				int	index = ins.mSIntConst[0];
+				int	index = ins->mSIntConst[0];
 				int areg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-				if (ins.mMemory == IM_LOCAL)
-					index += proc->mLocalVars[ins.mVarIndex].mOffset;
+				if (ins->mMemory == IM_LOCAL)
+					index += proc->mLocalVars[ins->mVarIndex].mOffset;
 				else
-					index += ins.mVarIndex + proc->mLocalSize + 2;
+					index += ins->mVarIndex + proc->mLocalSize + 2;
 				CheckFrameIndex(areg, index, 4);
 
 				mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
@@ -2072,30 +2072,30 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 		}
 		else
 		{
-			if (ins.mMemory == IM_INDIRECT)
+			if (ins->mMemory == IM_INDIRECT)
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins.mSIntConst[0]));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins->mSIntConst[0]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
 				mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 				mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 2));
 				mIns.Push(NativeCodeInstruction(ASMIT_INY, ASMIM_IMPLIED));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 3));
 			}
 		}
 	}
-	else if (ins.mTType == IT_POINTER)
+	else if (ins->mTType == IT_POINTER)
 	{
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{
-			if (ins.mMemory == IM_GLOBAL)
+			if (ins->mMemory == IM_GLOBAL)
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0], ins.mVarIndex));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0], ins->mVarIndex));
 				if (ainsl)
 				{
 					if (ainsl->mType == ASMIT_ADC)
@@ -2105,13 +2105,13 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 					mIns.Push(*ainsl);
 				}
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0] + 1, ins.mVarIndex));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0] + 1, ins->mVarIndex));
 				if (ainsh) mIns.Push(*ainsh);
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 			}
-			else if (ins.mMemory == IM_ABSOLUTE)
+			else if (ins->mMemory == IM_ABSOLUTE)
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0]));
 				if (ainsl)
 				{
 					if (ainsl->mType == ASMIT_ADC)
@@ -2121,18 +2121,18 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 					mIns.Push(*ainsl);
 				}
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0] + 1));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0] + 1));
 				if (ainsh) mIns.Push(*ainsh);
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 			}
-			else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+			else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 			{
-				int	index = ins.mSIntConst[0];
+				int	index = ins->mSIntConst[0];
 				int areg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-				if (ins.mMemory == IM_LOCAL)
-					index += proc->mLocalVars[ins.mVarIndex].mOffset;
+				if (ins->mMemory == IM_LOCAL)
+					index += proc->mLocalVars[ins->mVarIndex].mOffset;
 				else
-					index += ins.mVarIndex + proc->mLocalSize + 2;
+					index += ins->mVarIndex + proc->mLocalSize + 2;
 				CheckFrameIndex(areg, index, 2);
 
 				mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
@@ -2154,10 +2154,10 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 		}
 		else
 		{
-			if (ins.mMemory == IM_INDIRECT)
+			if (ins->mMemory == IM_INDIRECT)
 			{
-				int	src = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
-				mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins.mSIntConst[0]));
+				int	src = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
+				mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins->mSIntConst[0]));
 				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, src));
 				if (ainsl)
 				{
@@ -2182,26 +2182,26 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 	}
 	else
 	{
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{
-			if (ins.mOperandSize == 1)
+			if (ins->mOperandSize == 1)
 			{
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0], ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0], ins->mVarIndex));
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0]));
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[0];
+					int	index = ins->mSIntConst[0];
 					int areg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 					CheckFrameIndex(areg, index, 2);
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
@@ -2218,18 +2218,18 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 				}
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
 
-				if (InterTypeSize[ins.mTType] > 1)
+				if (InterTypeSize[ins->mTType] > 1)
 				{
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, 0));
 					if (ainsh) mIns.Push(*ainsh);
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 				}
 			}
-			else if (ins.mOperandSize == 2)
+			else if (ins->mOperandSize == 2)
 			{
-				if (ins.mMemory == IM_GLOBAL)
+				if (ins->mMemory == IM_GLOBAL)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0], ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0], ins->mVarIndex));
 					if (ainsl)
 					{
 						if (ainsl->mType == ASMIT_ADC)
@@ -2239,13 +2239,13 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 						mIns.Push(*ainsl);
 					}
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0] + 1, ins.mVarIndex));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0] + 1, ins->mVarIndex));
 					if (ainsh) mIns.Push(*ainsh);
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 				}
-				else if (ins.mMemory == IM_ABSOLUTE)
+				else if (ins->mMemory == IM_ABSOLUTE)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0]));
 					if (ainsl)
 					{
 						if (ainsl->mType == ASMIT_ADC)
@@ -2255,18 +2255,18 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 						mIns.Push(*ainsl);
 					}
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins.mSIntConst[0] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ABSOLUTE, ins->mSIntConst[0] + 1));
 					if (ainsh) mIns.Push(*ainsh);
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 				}
-				else if (ins.mMemory == IM_LOCAL || ins.mMemory == IM_PARAM)
+				else if (ins->mMemory == IM_LOCAL || ins->mMemory == IM_PARAM)
 				{
-					int	index = ins.mSIntConst[0];
+					int	index = ins->mSIntConst[0];
 					int areg = mNoFrame ? BC_REG_STACK : BC_REG_LOCALS;
-					if (ins.mMemory == IM_LOCAL)
-						index += proc->mLocalVars[ins.mVarIndex].mOffset;
+					if (ins->mMemory == IM_LOCAL)
+						index += proc->mLocalVars[ins->mVarIndex].mOffset;
 					else
-						index += ins.mVarIndex + proc->mLocalSize + 2;
+						index += ins->mVarIndex + proc->mLocalSize + 2;
 					CheckFrameIndex(areg, index, 2);
 
 					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, index));
@@ -2289,12 +2289,12 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 		}
 		else
 		{
-			if (ins.mMemory == IM_INDIRECT)
+			if (ins->mMemory == IM_INDIRECT)
 			{
-				if (ins.mOperandSize == 1)
+				if (ins->mOperandSize == 1)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins.mSIntConst[0]));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins->mSIntConst[0]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 					if (ainsl)
 					{
 						if (ainsl->mType == ASMIT_ADC)
@@ -2304,18 +2304,18 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 						mIns.Push(*ainsl);
 					}
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg));
-					if (InterTypeSize[ins.mTType] > 1)
+					if (InterTypeSize[ins->mTType] > 1)
 					{
 						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, 0));
 						if (ainsh) mIns.Push(*ainsh);
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, reg + 1));
 					}
 				}
-				else if (ins.mOperandSize == 2)
+				else if (ins->mOperandSize == 2)
 				{
-					int	src = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
+					int	src = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
 
-					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins.mSIntConst[0]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, ins->mSIntConst[0]));
 					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_INDIRECT_Y, src));
 					if (ainsl)
 					{
@@ -2326,7 +2326,7 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 						mIns.Push(*ainsl);
 					}
 
-					if (InterTypeSize[ins.mTType] > 1)
+					if (InterTypeSize[ins->mTType] > 1)
 					{
 						if (reg == src)
 							mIns.Push(NativeCodeInstruction(ASMIT_TAX, ASMIM_IMPLIED));
@@ -2348,16 +2348,16 @@ void NativeCodeBasicBlock::LoadValueToReg(InterCodeProcedure* proc, const InterI
 	}
 }
 
-void NativeCodeBasicBlock::LoadValue(InterCodeProcedure* proc, const InterInstruction& ins)
+void NativeCodeBasicBlock::LoadValue(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	LoadValueToReg(proc, ins, BC_REG_TMP + proc->mTempOffset[ins.mTTemp], nullptr, nullptr);
+	LoadValueToReg(proc, ins, BC_REG_TMP + proc->mTempOffset[ins->mTTemp], nullptr, nullptr);
 }
 
-void NativeCodeBasicBlock::CopyValue(InterCodeProcedure* proc, const InterInstruction& ins, NativeCodeProcedure* nproc)
+void NativeCodeBasicBlock::CopyValue(InterCodeProcedure* proc, const InterInstruction * ins, NativeCodeProcedure* nproc)
 {
-	int	sreg = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]], dreg = BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]];
+	int	sreg = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]], dreg = BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]];
 
-	int	size = ins.mOperandSize;
+	int	size = ins->mOperandSize;
 	if (size < 4)
 	{
 		mIns.Push(NativeCodeInstruction(ASMIT_LDY, ASMIM_IMMEDIATE, 0));
@@ -2432,15 +2432,15 @@ void NativeCodeBasicBlock::ShiftRegisterLeft(InterCodeProcedure* proc, int reg,
 	}
 }
 
-int NativeCodeBasicBlock::ShortMultiply(InterCodeProcedure* proc, const InterInstruction& ins, const InterInstruction* sins, int index, int mul)
+int NativeCodeBasicBlock::ShortMultiply(InterCodeProcedure* proc, const InterInstruction * ins, const InterInstruction* sins, int index, int mul)
 {
 	if (sins)
-		LoadValueToReg(proc, *sins, BC_REG_ACCU, nullptr, nullptr);
+		LoadValueToReg(proc, sins, BC_REG_ACCU, nullptr, nullptr);
 	else
 	{
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[index]]));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[index]]));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[index]] + 1));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[index]] + 1));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
 	}
 
@@ -2491,7 +2491,7 @@ int NativeCodeBasicBlock::ShortMultiply(InterCodeProcedure* proc, const InterIns
 		ShiftRegisterLeft(proc, BC_REG_ACCU, lshift);
 		return BC_REG_ACCU;
 	default:
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[1] & 0xff));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[1] & 0xff));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 0));
 
 		mIns.Push(NativeCodeInstruction("mul16by8"));
@@ -2517,18 +2517,18 @@ static int Binlog(unsigned n)
 
 	return k;
 }
-void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterInstruction& ins, const InterInstruction * sins1, const InterInstruction * sins0)
+void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterInstruction * ins, const InterInstruction * sins1, const InterInstruction * sins0)
 {
-	int	treg = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+	int	treg = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 
-	if (ins.mTType == IT_FLOAT)
+	if (ins->mTType == IT_FLOAT)
 	{
-		int	sreg0 = ins.mSTemp[0] < 0 ? -1 : BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]];
+		int	sreg0 = ins->mSTemp[0] < 0 ? -1 : BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]];
 
-		if (ins.mSTemp[1] < 0)
+		if (ins->mSTemp[1] < 0)
 		{
 			union { float f; unsigned int v; } cc;
-			cc.f = ins.mSFloatConst[1];
+			cc.f = ins->mSFloatConst[1];
 
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, cc.v & 0xff));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
@@ -2541,31 +2541,31 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 		}
 		else if (sins1)
 		{
-			LoadValueToReg(proc, *sins1, BC_REG_ACCU, nullptr, nullptr);
+			LoadValueToReg(proc, sins1, BC_REG_ACCU, nullptr, nullptr);
 		}
-		else if (ins.mSFinal[1] && CheckPredAccuStore(BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]))
+		else if (ins->mSFinal[1] && CheckPredAccuStore(BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]))
 		{
 			// cull previous store from accu to temp using direcrt forwarding
 			mIns.SetSize(mIns.Size() - 8);
-			if (sreg0 == BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]])
+			if (sreg0 == BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]])
 				sreg0 = BC_REG_ACCU;
 		}
 		else
 		{
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 0));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 0));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 2));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 2));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 2));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 3));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 3));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
 		}
 
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{
 			union { float f; unsigned int v; } cc;
-			cc.f = ins.mSFloatConst[0];
+			cc.f = ins->mSFloatConst[0];
 
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, cc.v & 0xff));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 0));
@@ -2578,7 +2578,7 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 		}
 		else if (sins0)
 		{
-			LoadValueToReg(proc, *sins0, BC_REG_WORK, nullptr, nullptr);
+			LoadValueToReg(proc, sins0, BC_REG_WORK, nullptr, nullptr);
 		}
 		else
 		{
@@ -2593,7 +2593,7 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 		}
 
 		mIns.Push(NativeCodeInstruction("fsplitt"));
-		switch (ins.mOperator)
+		switch (ins->mOperator)
 		{
 		case IA_ADD:
 			mIns.Push(NativeCodeInstruction("faddsub"));
@@ -2614,26 +2614,26 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 		}
 
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 0));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 0));
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 2));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 2));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 2));
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 3));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 3));
 	}
 	else
 	{
-		switch (ins.mOperator)
+		switch (ins->mOperator)
 		{
 		case IA_ADD:
 		case IA_OR:
 		case IA_AND:
 		case IA_XOR:
 		{
-			if (ins.mOperator == IA_ADD && (
-				ins.mSTemp[0] < 0 && ins.mSIntConst[0] == 1 && !sins1 && ins.mSTemp[1] == ins.mTTemp ||
-				ins.mSTemp[1] < 0 && ins.mSIntConst[1] == 1 && !sins0 && ins.mSTemp[0] == ins.mTTemp))
+			if (ins->mOperator == IA_ADD && (
+				ins->mSTemp[0] < 0 && ins->mSIntConst[0] == 1 && !sins1 && ins->mSTemp[1] == ins->mTTemp ||
+				ins->mSTemp[1] < 0 && ins->mSIntConst[1] == 1 && !sins0 && ins->mSTemp[0] == ins->mTTemp))
 			{
 				mIns.Push(NativeCodeInstruction(ASMIT_INC, ASMIM_ZERO_PAGE, treg));
 				mIns.Push(NativeCodeInstruction(ASMIT_BNE, ASMIM_RELATIVE, 2));
@@ -2644,7 +2644,7 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 				NativeCodeInstruction	insl, insh;
 
 				AsmInsType	atype;
-				switch (ins.mOperator)
+				switch (ins->mOperator)
 				{
 				case IA_ADD:
 					atype = ASMIT_ADC;
@@ -2660,38 +2660,38 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 					break;
 				}
 
-				if (ins.mSTemp[1] < 0)
+				if (ins->mSTemp[1] < 0)
 				{
-					insl = NativeCodeInstruction(atype, ASMIM_IMMEDIATE, ins.mSIntConst[1] & 0xff);
-					insh = NativeCodeInstruction(atype, ASMIM_IMMEDIATE, (ins.mSIntConst[1] >> 8) & 0xff);
+					insl = NativeCodeInstruction(atype, ASMIM_IMMEDIATE, ins->mSIntConst[1] & 0xff);
+					insh = NativeCodeInstruction(atype, ASMIM_IMMEDIATE, (ins->mSIntConst[1] >> 8) & 0xff);
 					if (sins0)
-						LoadValueToReg(proc, *sins0, treg, &insl, &insh);
+						LoadValueToReg(proc, sins0, treg, &insl, &insh);
 					else
 					{
-						if (ins.mOperator == IA_ADD)
+						if (ins->mOperator == IA_ADD)
 							mIns.Push(NativeCodeInstruction(ASMIT_CLC, ASMIM_IMPLIED));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 						mIns.Push(insl);
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 						mIns.Push(insh);
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 					}
 				}
-				else if (ins.mSTemp[0] < 0)
+				else if (ins->mSTemp[0] < 0)
 				{
-					insl = NativeCodeInstruction(atype, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff);
-					insh = NativeCodeInstruction(atype, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff);
+					insl = NativeCodeInstruction(atype, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff);
+					insh = NativeCodeInstruction(atype, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff);
 					if (sins1)
-						LoadValueToReg(proc, *sins1, treg, &insl, &insh);
+						LoadValueToReg(proc, sins1, treg, &insl, &insh);
 					else
 					{
-						if (ins.mOperator == IA_ADD)
+						if (ins->mOperator == IA_ADD)
 							mIns.Push(NativeCodeInstruction(ASMIT_CLC, ASMIM_IMPLIED));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 						mIns.Push(insl);
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 						mIns.Push(insh);
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 					}
@@ -2703,32 +2703,32 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 						insl = NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, treg);
 						insh = NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, treg + 1);
 
-						LoadValueToReg(proc, *sins1, treg, nullptr, nullptr);
-						LoadValueToReg(proc, *sins0, treg, &insl, &insh);
+						LoadValueToReg(proc, sins1, treg, nullptr, nullptr);
+						LoadValueToReg(proc, sins0, treg, &insl, &insh);
 					}
 					else if (sins1)
 					{
-						insl = NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]);
-						insh = NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1);
+						insl = NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]);
+						insh = NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1);
 
-						LoadValueToReg(proc, *sins1, treg, &insl, &insh);
+						LoadValueToReg(proc, sins1, treg, &insl, &insh);
 					}
 					else if (sins0)
 					{
-						insl = NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]);
-						insh = NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1);
+						insl = NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]);
+						insh = NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1);
 
-						LoadValueToReg(proc, *sins0, treg, &insl, &insh);
+						LoadValueToReg(proc, sins0, treg, &insl, &insh);
 					}
 					else
 					{
-						if (ins.mOperator == IA_ADD)
+						if (ins->mOperator == IA_ADD)
 							mIns.Push(NativeCodeInstruction(ASMIT_CLC, ASMIM_IMPLIED));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
-						mIns.Push(NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
-						mIns.Push(NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
+						mIns.Push(NativeCodeInstruction(atype, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 					}
 				}
@@ -2738,45 +2738,45 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 		{
 			NativeCodeInstruction	insl, insh;
 
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				insl = NativeCodeInstruction(ASMIT_SBC, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff);
-				insh = NativeCodeInstruction(ASMIT_SBC, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff);
+				insl = NativeCodeInstruction(ASMIT_SBC, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff);
+				insh = NativeCodeInstruction(ASMIT_SBC, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff);
 				if (sins1)
-					LoadValueToReg(proc, *sins1, treg, &insl, &insh);
+					LoadValueToReg(proc, sins1, treg, &insl, &insh);
 				else
 				{
 					mIns.Push(NativeCodeInstruction(ASMIT_SEC, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(insl);
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 					mIns.Push(insh);
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 				}
 			}
-			else if (ins.mSTemp[1] < 0)
+			else if (ins->mSTemp[1] < 0)
 			{
 				if (sins0)
 				{
 					insl = NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, treg);
 					insh = NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, treg + 1);
 
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[1] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[1] & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[1] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[1] >> 8) & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 
-					LoadValueToReg(proc, *sins0, treg, &insl, &insh);
+					LoadValueToReg(proc, sins0, treg, &insl, &insh);
 				}
 				else
 				{
 					mIns.Push(NativeCodeInstruction(ASMIT_SEC, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[1] & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[1] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[1] >> 8) & 0xff));
-					mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[1] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 				}
 			}
@@ -2787,25 +2787,25 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 					insl = NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_WORK + 0);
 					insh = NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_WORK + 1);
 
-					LoadValueToReg(proc, *sins0, BC_REG_WORK, nullptr, nullptr);
+					LoadValueToReg(proc, sins0, BC_REG_WORK, nullptr, nullptr);
 				}
 				else
 				{
-					insl = NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]);
-					insh = NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1);
+					insl = NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]);
+					insh = NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1);
 				}
 
 				if (sins1)
 				{
-					LoadValueToReg(proc, *sins1, treg, &insl, &insh);
+					LoadValueToReg(proc, sins1, treg, &insl, &insh);
 				}
 				else
 				{
 					mIns.Push(NativeCodeInstruction(ASMIT_SEC, ASMIM_IMPLIED));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(insl);
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 					mIns.Push(insh);
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 				}
@@ -2819,51 +2819,51 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 		{
 			int	reg = BC_REG_ACCU;
 
-			if (ins.mOperator == IA_MUL && ins.mSTemp[1] < 0 && (ins.mSIntConst[1] & ~0xff) == 0)
+			if (ins->mOperator == IA_MUL && ins->mSTemp[1] < 0 && (ins->mSIntConst[1] & ~0xff) == 0)
 			{
-				reg = ShortMultiply(proc, ins, sins0, 0, ins.mSIntConst[1] & 0xff);
+				reg = ShortMultiply(proc, ins, sins0, 0, ins->mSIntConst[1] & 0xff);
 			}
-			else if (ins.mOperator == IA_MUL && ins.mSTemp[0] < 0 && (ins.mSIntConst[0] & ~0xff) == 0)
+			else if (ins->mOperator == IA_MUL && ins->mSTemp[0] < 0 && (ins->mSIntConst[0] & ~0xff) == 0)
 			{
-				reg = ShortMultiply(proc, ins, sins1, 1, ins.mSIntConst[0] & 0xff);
+				reg = ShortMultiply(proc, ins, sins1, 1, ins->mSIntConst[0] & 0xff);
 			}
 			else
 			{
 				if (sins1)
-					LoadValueToReg(proc, *sins1, BC_REG_ACCU, nullptr, nullptr);
-				else if (ins.mSTemp[1] < 0)
+					LoadValueToReg(proc, sins1, BC_REG_ACCU, nullptr, nullptr);
+				else if (ins->mSTemp[1] < 0)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[1] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[1] & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[1] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[1] >> 8) & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
 				}
 				else
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
 				}
 
 				if (sins0)
-					LoadValueToReg(proc, *sins0, BC_REG_WORK, nullptr, nullptr);
-				else if (ins.mSTemp[0] < 0)
+					LoadValueToReg(proc, sins0, BC_REG_WORK, nullptr, nullptr);
+				else if (ins->mSTemp[0] < 0)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 0));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 1));
 				}
 				else
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 0));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 1));
 				}
 
-				switch (ins.mOperator)
+				switch (ins->mOperator)
 				{
 				case IA_MUL:
 					mIns.Push(NativeCodeInstruction("mul16"));
@@ -2887,36 +2887,36 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 			}
 
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, reg + 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp]));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp]));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, reg + 1));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 		} break;
 		case IA_SHL:
 		{
-			if (sins1) LoadValueToReg(proc, *sins1, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]], nullptr, nullptr);
-			if (sins0) LoadValueToReg(proc, *sins0, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]], nullptr, nullptr);
+			if (sins1) LoadValueToReg(proc, sins1, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]], nullptr, nullptr);
+			if (sins0) LoadValueToReg(proc, sins0, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]], nullptr, nullptr);
 
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				int	shift = ins.mSIntConst[0] & 15;
+				int	shift = ins->mSIntConst[0] & 15;
 				if (shift == 0)
 				{
-					if (ins.mSTemp[1] != ins.mTTemp)
+					if (ins->mSTemp[1] != ins->mTTemp)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 					}
 				}
 				else if (shift == 1)
 				{
-					if (ins.mSTemp[1] != ins.mTTemp)
+					if (ins->mSTemp[1] != ins->mTTemp)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_ASL, ASMIM_IMPLIED));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 						mIns.Push(NativeCodeInstruction(ASMIT_ROL, ASMIM_IMPLIED));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 					}
@@ -2928,12 +2928,12 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 				}
 				else
 				{
-					if (ins.mSTemp[1] != ins.mTTemp)
+					if (ins->mSTemp[1] != ins->mTTemp)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_ASL, ASMIM_IMPLIED));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 					}
 					else
 					{
@@ -2949,11 +2949,11 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 				}
 			}
-			else if (ins.mSTemp[1] < 0 && IsPowerOf2(ins.mSIntConst[1] & 0xffff))
+			else if (ins->mSTemp[1] < 0 && IsPowerOf2(ins->mSIntConst[1] & 0xffff))
 			{
-				int	l = Binlog(ins.mSIntConst[1] & 0xffff);
+				int	l = Binlog(ins->mSIntConst[1] & 0xffff);
 
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 				mIns.Push(NativeCodeInstruction(ASMIT_AND, ASMIM_IMMEDIATE, 0x0f));
 				mIns.Push(NativeCodeInstruction(ASMIT_TAX, ASMIM_IMPLIED));
 
@@ -2967,21 +2967,21 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 			}
 			else
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 				mIns.Push(NativeCodeInstruction(ASMIT_AND, ASMIM_IMMEDIATE, 0x0f));
 				mIns.Push(NativeCodeInstruction(ASMIT_TAX, ASMIM_IMPLIED));
 
-				if (ins.mSTemp[1] < 0)
+				if (ins->mSTemp[1] < 0)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[1] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[1] & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[1] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[1] >> 8) & 0xff));
 				}
-				else if (ins.mSTemp[1] != ins.mTTemp)
+				else if (ins->mSTemp[1] != ins->mTTemp)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 				}
 				else
 				{
@@ -3001,30 +3001,30 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 		} break;
 		case IA_SHR:
 		{
-			if (sins1) LoadValueToReg(proc, *sins1, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]], nullptr, nullptr);
-			if (sins0) LoadValueToReg(proc, *sins0, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]], nullptr, nullptr);
+			if (sins1) LoadValueToReg(proc, sins1, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]], nullptr, nullptr);
+			if (sins0) LoadValueToReg(proc, sins0, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]], nullptr, nullptr);
 
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				int	shift = ins.mSIntConst[0] & 15;
+				int	shift = ins->mSIntConst[0] & 15;
 				if (shift == 0)
 				{
-					if (ins.mSTemp[1] != ins.mTTemp)
+					if (ins->mSTemp[1] != ins->mTTemp)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 					}
 				}
 				else if (shift == 1)
 				{
-					if (ins.mSTemp[1] != ins.mTTemp)
+					if (ins->mSTemp[1] != ins->mTTemp)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 						mIns.Push(NativeCodeInstruction(ASMIT_LSR, ASMIM_IMPLIED));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_ROR, ASMIM_IMPLIED));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
 					}
@@ -3036,12 +3036,12 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 				}
 				else
 				{
-					if (ins.mSTemp[1] != ins.mTTemp)
+					if (ins->mSTemp[1] != ins->mTTemp)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 						mIns.Push(NativeCodeInstruction(ASMIT_LSR, ASMIM_IMPLIED));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					}
 					else
 					{
@@ -3057,11 +3057,11 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg ));
 				}
 			}
-			else if (ins.mSTemp[1] < 0 && IsPowerOf2(ins.mSIntConst[1] & 0xffff))
+			else if (ins->mSTemp[1] < 0 && IsPowerOf2(ins->mSIntConst[1] & 0xffff))
 			{
-				int	l = Binlog(ins.mSIntConst[1] & 0xffff);
+				int	l = Binlog(ins->mSIntConst[1] & 0xffff);
 
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 				mIns.Push(NativeCodeInstruction(ASMIT_AND, ASMIM_IMMEDIATE, 0x0f));
 				mIns.Push(NativeCodeInstruction(ASMIT_TAX, ASMIM_IMPLIED));
 
@@ -3072,21 +3072,21 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 			}
 			else
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 				mIns.Push(NativeCodeInstruction(ASMIT_AND, ASMIM_IMMEDIATE, 0x0f));
 				mIns.Push(NativeCodeInstruction(ASMIT_TAX, ASMIM_IMPLIED));
 
-				if (ins.mSTemp[1] < 0)
+				if (ins->mSTemp[1] < 0)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[1] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[1] & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[1] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[1] >> 8) & 0xff));
 				}
-				else if (ins.mSTemp[1] != ins.mTTemp)
+				else if (ins->mSTemp[1] != ins->mTTemp)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 				}
 				else
 				{
@@ -3106,29 +3106,29 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 		} break;
 		case IA_SAR:
 		{
-			if (sins1) LoadValueToReg(proc, *sins1, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]], nullptr, nullptr);
-			if (sins0) LoadValueToReg(proc, *sins0, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]], nullptr, nullptr);
+			if (sins1) LoadValueToReg(proc, sins1, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]], nullptr, nullptr);
+			if (sins0) LoadValueToReg(proc, sins0, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]], nullptr, nullptr);
 
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				int	shift = ins.mSIntConst[0] & 15;
+				int	shift = ins->mSIntConst[0] & 15;
 				if (shift == 0)
 				{
-					if (ins.mSTemp[1] != ins.mTTemp)
+					if (ins->mSTemp[1] != ins->mTTemp)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 					}
 				}
 				else
 				{
-					if (ins.mSTemp[1] != ins.mTTemp)
+					if (ins->mSTemp[1] != ins->mTTemp)
 					{
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 						mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+						mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 					}
 					else
 					{
@@ -3145,11 +3145,11 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 				}
 			}
-			else if (ins.mSTemp[1] < 0 && IsPowerOf2(ins.mSIntConst[1] & 0xffff))
+			else if (ins->mSTemp[1] < 0 && IsPowerOf2(ins->mSIntConst[1] & 0xffff))
 			{
-				int	l = Binlog(ins.mSIntConst[1] & 0xffff);
+				int	l = Binlog(ins->mSIntConst[1] & 0xffff);
 
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 				mIns.Push(NativeCodeInstruction(ASMIT_AND, ASMIM_IMMEDIATE, 0x0f));
 				mIns.Push(NativeCodeInstruction(ASMIT_TAX, ASMIM_IMPLIED));
 
@@ -3173,21 +3173,21 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 			}
 			else
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 				mIns.Push(NativeCodeInstruction(ASMIT_AND, ASMIM_IMMEDIATE, 0x0f));
 				mIns.Push(NativeCodeInstruction(ASMIT_TAX, ASMIM_IMPLIED));
 
-				if (ins.mSTemp[1] < 0)
+				if (ins->mSTemp[1] < 0)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[1] & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[1] & 0xff));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[1] >> 8) & 0xff));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[1] >> 8) & 0xff));
 				}
-				else if (ins.mSTemp[1] != ins.mTTemp)
+				else if (ins->mSTemp[1] != ins->mTTemp)
 				{
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 					mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
-					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+					mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 				}
 				else
 				{
@@ -3211,157 +3211,157 @@ void NativeCodeBasicBlock::BinaryOperator(InterCodeProcedure* proc, const InterI
 	}
 }
 
-void NativeCodeBasicBlock::UnaryOperator(InterCodeProcedure* proc, const InterInstruction& ins)
+void NativeCodeBasicBlock::UnaryOperator(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	int	treg = BC_REG_TMP + proc->mTempOffset[ins.mTTemp];
+	int	treg = BC_REG_TMP + proc->mTempOffset[ins->mTTemp];
 
-	if (ins.mTType == IT_FLOAT)
+	if (ins->mTType == IT_FLOAT)
 	{
-		switch (ins.mOperator)
+		switch (ins->mOperator)
 		{
 		case IA_NEG:
 		case IA_ABS:
-			if (ins.mSTemp[0] != ins.mTTemp)
+			if (ins->mSTemp[0] != ins->mTTemp)
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 0));
-				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 0));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
-				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 2));
-				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 2));
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 3));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 0));
+				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 0));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
+				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 2));
+				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 2));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 3));
 			}
 			else
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 3));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 3));
 
-			if (ins.mOperator == IA_NEG)
+			if (ins->mOperator == IA_NEG)
 				mIns.Push(NativeCodeInstruction(ASMIT_EOR, ASMIM_IMMEDIATE, 0x80));
 			else
 				mIns.Push(NativeCodeInstruction(ASMIT_AND, ASMIM_IMMEDIATE, 0x7f));
 
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 3));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 3));
 			break;
 		case IA_FLOOR:
 		case IA_CEIL:
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 0));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 0));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 2));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 2));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 2));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 3));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 3));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
 
-			if (ins.mOperator == IA_FLOOR)
+			if (ins->mOperator == IA_FLOOR)
 				mIns.Push(NativeCodeInstruction("ffloor"));
 			else
 				mIns.Push(NativeCodeInstruction("fceil"));
 
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 0));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 0));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 2));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 2));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 2));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 3));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 3));
 			break;
 		}
 	}
 	else
 	{
-		switch (ins.mOperator)
+		switch (ins->mOperator)
 		{
 		case IA_NEG:
 			mIns.Push(NativeCodeInstruction(ASMIT_SEC, ASMIM_IMPLIED));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+			mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 			break;
 
 		case IA_NOT:
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, 0xff));
-			mIns.Push(NativeCodeInstruction(ASMIT_EOR, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+			mIns.Push(NativeCodeInstruction(ASMIT_EOR, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, 0xff));
-			mIns.Push(NativeCodeInstruction(ASMIT_EOR, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_EOR, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, treg + 1));
 			break;
 		}
 	}
 }
 
-void NativeCodeBasicBlock::NumericConversion(InterCodeProcedure* proc, const InterInstruction& ins)
+void NativeCodeBasicBlock::NumericConversion(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	switch (ins.mOperator)
+	switch (ins->mOperator)
 	{
 	case IA_FLOAT2INT:
 	{
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 0));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 0));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 2));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 2));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 2));
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 3));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 3));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
 
 		mIns.Push(NativeCodeInstruction("ftoi"));
 
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 0));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 0));
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 
 	}	break;
 	case IA_INT2FLOAT:
 	{
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 0));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 0));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
 
 		mIns.Push(NativeCodeInstruction("ffromi"));
 
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 0));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 0));
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 2));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 2));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 2));
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 3));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 3));
 
 	} break;
 	case IA_EXT8TO16S:
 		mIns.Push(NativeCodeInstruction(ASMIT_LDX, ASMIM_IMMEDIATE, 0));
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-		if (ins.mSTemp[0] != ins.mTTemp)
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp]));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+		if (ins->mSTemp[0] != ins->mTTemp)
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp]));
 		mIns.Push(NativeCodeInstruction(ASMIT_BPL, ASMIM_RELATIVE, 1));
 		mIns.Push(NativeCodeInstruction(ASMIT_DEX, ASMIM_IMPLIED));
-		mIns.Push(NativeCodeInstruction(ASMIT_STX, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+		mIns.Push(NativeCodeInstruction(ASMIT_STX, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 		break;
 	case IA_EXT8TO16U:
-		if (ins.mSTemp[0] != ins.mTTemp)
+		if (ins->mSTemp[0] != ins->mTTemp)
 		{
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp]));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp]));
 		}
 		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, 0));
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 		break;
 	}
 }
 
-void NativeCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const InterInstruction& ins, NativeCodeProcedure* nproc, NativeCodeBasicBlock* trueJump, NativeCodeBasicBlock* falseJump)
+void NativeCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const InterInstruction * ins, NativeCodeProcedure* nproc, NativeCodeBasicBlock* trueJump, NativeCodeBasicBlock* falseJump)
 {
-	InterOperator	op = ins.mOperator;
+	InterOperator	op = ins->mOperator;
 
-	if (ins.mSType[0] == IT_FLOAT)
+	if (ins->mSType[0] == IT_FLOAT)
 	{
 		int	li = 0, ri = 1;
 		if (op == IA_CMPLEU || op == IA_CMPGU || op == IA_CMPLES || op == IA_CMPGS)
@@ -3369,10 +3369,10 @@ void NativeCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const In
 			li = 1; ri = 0;
 		}
 
-		if (ins.mSTemp[li] < 0)
+		if (ins->mSTemp[li] < 0)
 		{
 			union { float f; unsigned int v; } cc;
-			cc.f = ins.mSFloatConst[li];
+			cc.f = ins->mSFloatConst[li];
 
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, cc.v & 0xff));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
@@ -3383,27 +3383,27 @@ void NativeCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const In
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (cc.v >> 24) & 0xff));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
 		}
-		else if (ins.mSFinal[li] && CheckPredAccuStore(BC_REG_TMP + proc->mTempOffset[ins.mSTemp[li]]))
+		else if (ins->mSFinal[li] && CheckPredAccuStore(BC_REG_TMP + proc->mTempOffset[ins->mSTemp[li]]))
 		{
 			// cull previous store from accu to temp using direcrt forwarding
 			mIns.SetSize(mIns.Size() - 8);
 		}
 		else
 		{
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[li]] + 0));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[li]] + 0));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[li]] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[li]] + 1));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[li]] + 2));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[li]] + 2));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 2));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[li]] + 3));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[li]] + 3));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
 		}
 
-		if (ins.mSTemp[ri] < 0)
+		if (ins->mSTemp[ri] < 0)
 		{
 			union { float f; unsigned int v; } cc;
-			cc.f = ins.mSFloatConst[ri];
+			cc.f = ins->mSFloatConst[ri];
 
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, cc.v & 0xff));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 0));
@@ -3416,13 +3416,13 @@ void NativeCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const In
 		}
 		else
 		{
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[ri]] + 0));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[ri]] + 0));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[ri]] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[ri]] + 1));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 1));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[ri]] + 2));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[ri]] + 2));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 2));
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[ri]] + 3));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[ri]] + 3));
 			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK + 3));
 		}
 
@@ -3461,50 +3461,50 @@ void NativeCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const In
 			li = 0; ri = 1;
 		}
 
-		if (op >= IA_CMPGES && ins.mOperator <= IA_CMPLS)
+		if (op >= IA_CMPGES && ins->mOperator <= IA_CMPLS)
 		{
-			if (ins.mSTemp[ri] >= 0)
+			if (ins->mSTemp[ri] >= 0)
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[ri]] + 1));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[ri]] + 1));
 				mIns.Push(NativeCodeInstruction(ASMIT_EOR, ASMIM_IMMEDIATE, 0x80));
 				mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_WORK));
 			}
 
-			if (ins.mSTemp[li] < 0)
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ((ins.mSIntConst[li] >> 8) & 0xff) ^ 0x80));
+			if (ins->mSTemp[li] < 0)
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ((ins->mSIntConst[li] >> 8) & 0xff) ^ 0x80));
 			else
 			{
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[li]] + 1));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[li]] + 1));
 				mIns.Push(NativeCodeInstruction(ASMIT_EOR, ASMIM_IMMEDIATE, 0x80));
 			}
 
-			if (ins.mSTemp[ri] < 0)
-				mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_IMMEDIATE, ((ins.mSIntConst[ri] >> 8) & 0xff) ^ 0x80));
+			if (ins->mSTemp[ri] < 0)
+				mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_IMMEDIATE, ((ins->mSIntConst[ri] >> 8) & 0xff) ^ 0x80));
 			else
 				mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_ZERO_PAGE, BC_REG_WORK));
 		}
 		else
 		{
-			if (ins.mSTemp[li] < 0)
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[li] >> 8) & 0xff));
+			if (ins->mSTemp[li] < 0)
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[li] >> 8) & 0xff));
 			else
-				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[li]] + 1));
-			if (ins.mSTemp[ri] < 0)
-				mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_IMMEDIATE, (ins.mSIntConst[ri] >> 8) & 0xff));
+				mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[li]] + 1));
+			if (ins->mSTemp[ri] < 0)
+				mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_IMMEDIATE, (ins->mSIntConst[ri] >> 8) & 0xff));
 			else
-				mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[ri]] + 1));
+				mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[ri]] + 1));
 		}
 
 		this->Close(nblock, eblock, ASMIT_BNE);
 
-		if (ins.mSTemp[li] < 0)
-			eblock->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[li] & 0xff));
+		if (ins->mSTemp[li] < 0)
+			eblock->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[li] & 0xff));
 		else
-			eblock->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[li]]));
-		if (ins.mSTemp[ri] < 0)
-			eblock->mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_IMMEDIATE, ins.mSIntConst[ri] & 0xff));
+			eblock->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[li]]));
+		if (ins->mSTemp[ri] < 0)
+			eblock->mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_IMMEDIATE, ins->mSIntConst[ri] & 0xff));
 		else
-			eblock->mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[ri]]));
+			eblock->mIns.Push(NativeCodeInstruction(ASMIT_CMP, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[ri]]));
 
 		switch (op)
 		{
@@ -3535,75 +3535,75 @@ void NativeCodeBasicBlock::RelationalOperator(InterCodeProcedure* proc, const In
 	}
 }
 
-void NativeCodeBasicBlock::LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction& ins, const InterInstruction* sins1, const InterInstruction* sins0)
+void NativeCodeBasicBlock::LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction * ins, const InterInstruction* sins1, const InterInstruction* sins0)
 {
 	if (sins1)
 	{
-		if (ins.mSTemp[0] < 0 && ins.mSIntConst[0] == 0)
-			LoadValueToReg(proc, *sins1, ins.mTTemp, nullptr, nullptr);
+		if (ins->mSTemp[0] < 0 && ins->mSIntConst[0] == 0)
+			LoadValueToReg(proc, sins1, ins->mTTemp, nullptr, nullptr);
 		else
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				NativeCodeInstruction	ainsl(ASMIT_ADC, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff);
-				NativeCodeInstruction	ainsh(ASMIT_ADC, ASMIM_IMMEDIATE, (ins.mSIntConst[1] >> 8) & 0xff);
+				NativeCodeInstruction	ainsl(ASMIT_ADC, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff);
+				NativeCodeInstruction	ainsh(ASMIT_ADC, ASMIM_IMMEDIATE, (ins->mSIntConst[1] >> 8) & 0xff);
 
-				LoadValueToReg(proc, *sins1, BC_REG_TMP + proc->mTempOffset[ins.mTTemp], &ainsl, &ainsh);
+				LoadValueToReg(proc, sins1, BC_REG_TMP + proc->mTempOffset[ins->mTTemp], &ainsl, &ainsh);
 			}
 			else
 			{
-				NativeCodeInstruction	ainsl(ASMIT_ADC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]);
-				NativeCodeInstruction	ainsh(ASMIT_ADC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1);
+				NativeCodeInstruction	ainsl(ASMIT_ADC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]);
+				NativeCodeInstruction	ainsh(ASMIT_ADC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1);
 
-				LoadValueToReg(proc, *sins1, BC_REG_TMP + proc->mTempOffset[ins.mTTemp], &ainsl, &ainsh);
+				LoadValueToReg(proc, sins1, BC_REG_TMP + proc->mTempOffset[ins->mTTemp], &ainsl, &ainsh);
 			}
 		}
 	}
 	else
 	{
-		if (ins.mSTemp[0] >= 0 || ins.mSIntConst[0] != 0)
+		if (ins->mSTemp[0] >= 0 || ins->mSIntConst[0] != 0)
 			mIns.Push(NativeCodeInstruction(ASMIT_CLC, ASMIM_IMPLIED));
 
-		if (ins.mSTemp[1] < 0)
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[1] & 0xff));
+		if (ins->mSTemp[1] < 0)
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[1] & 0xff));
 		else
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]]));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]]));
 
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{
-			if (ins.mSIntConst[0])
-				mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
+			if (ins->mSIntConst[0])
+				mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
 		}
 		else
-			mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]]));
+			mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]]));
 
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp]));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp]));
 
-		if (ins.mSTemp[1] < 0)
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[1] >> 8) & 0xff));
+		if (ins->mSTemp[1] < 0)
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[1] >> 8) & 0xff));
 		else
-			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[1]] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[1]] + 1));
 
-		if (ins.mSTemp[0] < 0)
+		if (ins->mSTemp[0] < 0)
 		{
-			if (ins.mSIntConst[0])
-				mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
+			if (ins->mSIntConst[0])
+				mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
 		}
 		else
-			mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 
-		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 	}
 }
 
-void NativeCodeBasicBlock::CallFunction(InterCodeProcedure* proc, const InterInstruction& ins)
+void NativeCodeBasicBlock::CallFunction(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	if (ins.mSTemp[0] < 0)
+	if (ins->mSTemp[0] < 0)
 	{
-		NativeCodeInstruction	lins(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins.mSIntConst[0], ins.mVarIndex, true, false);
-		lins.mFunction = ins.mMemory == IM_PROCEDURE;
-		NativeCodeInstruction	hins(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins.mSIntConst[0], ins.mVarIndex, false, true);
-		hins.mFunction = ins.mMemory == IM_PROCEDURE;
+		NativeCodeInstruction	lins(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins->mSIntConst[0], ins->mVarIndex, true, false);
+		lins.mFunction = ins->mMemory == IM_PROCEDURE;
+		NativeCodeInstruction	hins(ASMIT_LDA, ASMIM_IMMEDIATE_ADDRESS, ins->mSIntConst[0], ins->mVarIndex, false, true);
+		hins.mFunction = ins->mMemory == IM_PROCEDURE;
 
 		mIns.Push(lins);
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU));
@@ -3612,62 +3612,62 @@ void NativeCodeBasicBlock::CallFunction(InterCodeProcedure* proc, const InterIns
 	}
 	else
 	{
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 0));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 0));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU));
-		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mSTemp[0]] + 1));
+		mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mSTemp[0]] + 1));
 		mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
 	}
 
 	mIns.Push(NativeCodeInstruction("bcexec"));
 
-	if (ins.mTTemp >= 0)
+	if (ins->mTTemp >= 0)
 	{
-		if (ins.mTType == IT_FLOAT)
+		if (ins->mTType == IT_FLOAT)
 		{
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 0));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 0));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 2));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 2));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 2));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 3));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 3));
 		}
 		else
 		{
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 0));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 0));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 		}
 	}
 }
 
-void NativeCodeBasicBlock::CallAssembler(InterCodeProcedure* proc, const InterInstruction& ins)
+void NativeCodeBasicBlock::CallAssembler(InterCodeProcedure* proc, const InterInstruction * ins)
 {
-	NativeCodeInstruction	ains(ASMIT_JSR, ASMIM_ABSOLUTE, ins.mSIntConst[0], ins.mVarIndex, true, true);
-	ains.mFunction = ins.mMemory == IM_PROCEDURE;
+	NativeCodeInstruction	ains(ASMIT_JSR, ASMIM_ABSOLUTE, ins->mSIntConst[0], ins->mVarIndex, true, true);
+	ains.mFunction = ins->mMemory == IM_PROCEDURE;
 	mIns.Push(ains);
 	
-	if (ins.mTTemp >= 0)
+	if (ins->mTTemp >= 0)
 	{
-		if (ins.mTType == IT_FLOAT)
+		if (ins->mTType == IT_FLOAT)
 		{
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 0));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 0));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 2));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 2));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 2));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 3));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 3));
 		}
 		else
 		{
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 0));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 0));
 			mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins.mTTemp] + 1));
+			mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + proc->mTempOffset[ins->mTTemp] + 1));
 		}
 	}
 }
@@ -4633,65 +4633,65 @@ void NativeCodeProcedure::CompileInterBlock(InterCodeProcedure* iproc, InterCode
 	int	i = 0;
 	while (i < iblock->mInstructions.Size())
 	{
-		const InterInstruction& ins = iblock->mInstructions[i];
+		const InterInstruction * ins = iblock->mInstructions[i];
 
-		switch (ins.mCode)
+		switch (ins->mCode)
 		{
 		case IC_STORE:
 			block->StoreValue(iproc, ins);
 			break;
 		case IC_LOAD:
 			if (i + 1 < iblock->mInstructions.Size() &&
-				iblock->mInstructions[i + 1].mCode == IC_STORE &&
-				iblock->mInstructions[i + 1].mSTemp[0] == ins.mTTemp &&
-				iblock->mInstructions[i + 1].mSFinal[0] &&
-				iblock->mInstructions[i + 1].mOperandSize == 1)
+				iblock->mInstructions[i + 1]->mCode == IC_STORE &&
+				iblock->mInstructions[i + 1]->mSTemp[0] == ins->mTTemp &&
+				iblock->mInstructions[i + 1]->mSFinal[0] &&
+				iblock->mInstructions[i + 1]->mOperandSize == 1)
 			{
 				block->LoadStoreValue(iproc, ins, iblock->mInstructions[i + 1]);
 				i++;
 			}
 			else if (i + 1 < iblock->mInstructions.Size() &&
-				ins.mOperandSize >= 2 &&
-				iblock->mInstructions[i + 1].mCode == IC_BINARY_OPERATOR &&
-				iblock->mInstructions[i + 1].mSTemp[0] == ins.mTTemp && iblock->mInstructions[i + 1].mSFinal[0])
+				ins->mOperandSize >= 2 &&
+				iblock->mInstructions[i + 1]->mCode == IC_BINARY_OPERATOR &&
+				iblock->mInstructions[i + 1]->mSTemp[0] == ins->mTTemp && iblock->mInstructions[i + 1]->mSFinal[0])
 			{
-				block->BinaryOperator(iproc, iblock->mInstructions[i + 1], nullptr, &ins);
+				block->BinaryOperator(iproc, iblock->mInstructions[i + 1], nullptr, ins);
 				i++;
 			}
 			else if (i + 1 < iblock->mInstructions.Size() &&
-				ins.mOperandSize >= 2 &&
-				iblock->mInstructions[i + 1].mCode == IC_BINARY_OPERATOR &&
-				iblock->mInstructions[i + 1].mSTemp[1] == ins.mTTemp && iblock->mInstructions[i + 1].mSFinal[1])
+				ins->mOperandSize >= 2 &&
+				iblock->mInstructions[i + 1]->mCode == IC_BINARY_OPERATOR &&
+				iblock->mInstructions[i + 1]->mSTemp[1] == ins->mTTemp && iblock->mInstructions[i + 1]->mSFinal[1])
 			{
-				block->BinaryOperator(iproc, iblock->mInstructions[i + 1], &ins, nullptr);
+				block->BinaryOperator(iproc, iblock->mInstructions[i + 1], ins, nullptr);
 				i++;
 			}
 			else if (i + 2 < iblock->mInstructions.Size() &&
-				ins.mOperandSize >= 2 &&
-				iblock->mInstructions[i + 1].mCode == IC_LOAD && iblock->mInstructions[i + 1].mOperandSize == 2 &&
-				iblock->mInstructions[i + 2].mCode == IC_BINARY_OPERATOR &&
-				iblock->mInstructions[i + 2].mSTemp[0] == iblock->mInstructions[i + 1].mTTemp && iblock->mInstructions[i + 2].mSFinal[0] &&
-				iblock->mInstructions[i + 2].mSTemp[1] == ins.mTTemp && iblock->mInstructions[i + 2].mSFinal[1])
+				ins->mOperandSize >= 2 &&
+				iblock->mInstructions[i + 1]->mCode == IC_LOAD && iblock->mInstructions[i + 1]->mOperandSize == 2 &&
+				iblock->mInstructions[i + 2]->mCode == IC_BINARY_OPERATOR &&
+				iblock->mInstructions[i + 2]->mSTemp[0] == iblock->mInstructions[i + 1]->mTTemp && iblock->mInstructions[i + 2]->mSFinal[0] &&
+				iblock->mInstructions[i + 2]->mSTemp[1] == ins->mTTemp && iblock->mInstructions[i + 2]->mSFinal[1])
 			{
-				block->BinaryOperator(iproc, iblock->mInstructions[i + 2], &ins, &(iblock->mInstructions[i + 1]));
+				block->BinaryOperator(iproc, iblock->mInstructions[i + 2], ins, iblock->mInstructions[i + 1]);
 				i += 2;
 			}
 			else if (i + 2 < iblock->mInstructions.Size() &&
-				ins.mOperandSize >= 2 &&
-				iblock->mInstructions[i + 1].mCode == IC_LOAD && iblock->mInstructions[i + 1].mOperandSize == 2 &&
-				iblock->mInstructions[i + 2].mCode == IC_BINARY_OPERATOR &&
-				iblock->mInstructions[i + 2].mSTemp[1] == iblock->mInstructions[i + 1].mTTemp && iblock->mInstructions[i + 2].mSFinal[1] &&
-				iblock->mInstructions[i + 2].mSTemp[0] == ins.mTTemp && iblock->mInstructions[i + 2].mSFinal[0])
+				ins->mOperandSize >= 2 &&
+				iblock->mInstructions[i + 1]->mCode == IC_LOAD && iblock->mInstructions[i + 1]->mOperandSize == 2 &&
+				iblock->mInstructions[i + 2]->mCode == IC_BINARY_OPERATOR &&
+				iblock->mInstructions[i + 2]->mSTemp[1] == iblock->mInstructions[i + 1]->mTTemp && iblock->mInstructions[i + 2]->mSFinal[1] &&
+				iblock->mInstructions[i + 2]->mSTemp[0] == ins->mTTemp && iblock->mInstructions[i + 2]->mSFinal[0])
 			{
-				block->BinaryOperator(iproc, iblock->mInstructions[i + 2], &(iblock->mInstructions[i + 1]), &ins);
+				block->BinaryOperator(iproc, iblock->mInstructions[i + 2], iblock->mInstructions[i + 1], ins);
 				i += 2;
 			}
 			else if (i + 1 < iblock->mInstructions.Size() &&
-				ins.mOperandSize >= 2 &&
-				iblock->mInstructions[i + 1].mCode == IC_LEA &&
-				iblock->mInstructions[i + 1].mSTemp[1] == ins.mTTemp && iblock->mInstructions[i + 1].mSFinal[1])
+				ins->mOperandSize >= 2 &&
+				iblock->mInstructions[i + 1]->mCode == IC_LEA &&
+				iblock->mInstructions[i + 1]->mSTemp[1] == ins->mTTemp && iblock->mInstructions[i + 1]->mSFinal[1])
 			{
-				block->LoadEffectiveAddress(iproc, iblock->mInstructions[i + 1], &ins, nullptr);
+				block->LoadEffectiveAddress(iproc, iblock->mInstructions[i + 1], ins, nullptr);
 				i++;
 			}
 			else
@@ -4702,12 +4702,12 @@ void NativeCodeProcedure::CompileInterBlock(InterCodeProcedure* iproc, InterCode
 			break;
 		case IC_LOAD_TEMPORARY:
 		{
-			if (ins.mSTemp[0] != ins.mTTemp)
+			if (ins->mSTemp[0] != ins->mTTemp)
 			{
-				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]]));
-				block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mTTemp]));
-				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]] + 1));
-				block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mTTemp] + 1));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]]));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mTTemp]));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]] + 1));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mTTemp] + 1));
 			}
 		}	break;
 		case IC_BINARY_OPERATOR:
@@ -4735,25 +4735,25 @@ void NativeCodeProcedure::CompileInterBlock(InterCodeProcedure* iproc, InterCode
 		{
 			block->mIns.Push(NativeCodeInstruction(ASMIT_SEC, ASMIM_IMPLIED));
 			block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_STACK));
-			block->mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_IMMEDIATE, (ins.mIntValue + 2) & 0xff));
+			block->mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_IMMEDIATE, (ins->mIntValue + 2) & 0xff));
 			block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_STACK));
 			block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_STACK + 1));
-			block->mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_IMMEDIATE, ((ins.mIntValue + 2) >> 8) & 0xff));
+			block->mIns.Push(NativeCodeInstruction(ASMIT_SBC, ASMIM_IMMEDIATE, ((ins->mIntValue + 2) >> 8) & 0xff));
 			block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_STACK + 1));
 		}	break;
 		case IC_POP_FRAME:
 		{
 			block->mIns.Push(NativeCodeInstruction(ASMIT_CLC, ASMIM_IMPLIED));
 			block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_STACK));
-			block->mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_IMMEDIATE, (ins.mIntValue + 2) & 0xff));
+			block->mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_IMMEDIATE, (ins->mIntValue + 2) & 0xff));
 			block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_STACK));
 			block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_STACK + 1));
-			block->mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_IMMEDIATE, ((ins.mIntValue + 2) >> 8) & 0xff));
+			block->mIns.Push(NativeCodeInstruction(ASMIT_ADC, ASMIM_IMMEDIATE, ((ins->mIntValue + 2) >> 8) & 0xff));
 			block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_STACK + 1));
 		}	break;
 
 		case IC_RELATIONAL_OPERATOR:
-			if (iblock->mInstructions[i + 1].mCode == IC_BRANCH)
+			if (iblock->mInstructions[i + 1]->mCode == IC_BRANCH)
 			{
 				block->RelationalOperator(iproc, ins, this, CompileBlock(iproc, iblock->mTrueJump), CompileBlock(iproc, iblock->mFalseJump));
 				return;
@@ -4773,11 +4773,11 @@ void NativeCodeProcedure::CompileInterBlock(InterCodeProcedure* iproc, InterCode
 				fblock->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, 0));
 				fblock->Close(rblock, nullptr, ASMIT_JMP);
 
-				rblock->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mTTemp]));
-				if (InterTypeSize[ins.mTType] > 1)
+				rblock->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mTTemp]));
+				if (InterTypeSize[ins->mTType] > 1)
 				{
 					rblock->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, 0));
-					rblock->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mTTemp] + 1));
+					rblock->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mTTemp] + 1));
 				}
 
 				block = rblock;
@@ -4786,12 +4786,12 @@ void NativeCodeProcedure::CompileInterBlock(InterCodeProcedure* iproc, InterCode
 
 		case IC_RETURN_VALUE:
 		{
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mSType[0] == IT_FLOAT)
+				if (ins->mSType[0] == IT_FLOAT)
 				{
 					union { float f; unsigned int v; } cc;
-					cc.f = ins.mSFloatConst[0];
+					cc.f = ins->mSFloatConst[0];
 
 					block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, cc.v & 0xff));
 					block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
@@ -4804,23 +4804,23 @@ void NativeCodeProcedure::CompileInterBlock(InterCodeProcedure* iproc, InterCode
 				}
 				else
 				{
-					block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins.mSIntConst[0] & 0xff));
+					block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, ins->mSIntConst[0] & 0xff));
 					block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 0));
-					block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins.mSIntConst[0] >> 8) & 0xff));
+					block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_IMMEDIATE, (ins->mSIntConst[0] >> 8) & 0xff));
 					block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
 				}
 			}				
 			else
 			{
-				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]]));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]]));
 				block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU));
-				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]] + 1));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]] + 1));
 				block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 1));
-				if (ins.mSType[0] == IT_FLOAT)
+				if (ins->mSType[0] == IT_FLOAT)
 				{
-					block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]] + 2));
+					block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]] + 2));
 					block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 2));
-					block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]] + 3));
+					block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]] + 3));
 					block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_ACCU + 3));
 				}
 			}
@@ -4834,28 +4834,28 @@ void NativeCodeProcedure::CompileInterBlock(InterCodeProcedure* iproc, InterCode
 			return;
 
 		case IC_TYPECAST:
-			if (ins.mSTemp[0] != ins.mTTemp)
+			if (ins->mSTemp[0] != ins->mTTemp)
 			{
-				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]]));
-				block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mTTemp]));
-				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]] + 1));
-				block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mTTemp] + 1));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]]));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mTTemp]));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]] + 1));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_STA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mTTemp] + 1));
 			}
 			break;
 
 		case IC_BRANCH:
-			if (ins.mSTemp[0] < 0)
+			if (ins->mSTemp[0] < 0)
 			{
-				if (ins.mSIntConst[0] == 0)
+				if (ins->mSIntConst[0] == 0)
 					block->Close(CompileBlock(iproc, iblock->mFalseJump), nullptr, ASMIT_JMP);
 				else
 					block->Close(CompileBlock(iproc, iblock->mTrueJump), nullptr, ASMIT_JMP);
 			}
 			else
 			{
-				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]]));
-				if (InterTypeSize[ins.mSType[0]] > 1)
-					block->mIns.Push(NativeCodeInstruction(ASMIT_ORA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins.mSTemp[0]] + 1));
+				block->mIns.Push(NativeCodeInstruction(ASMIT_LDA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]]));
+				if (InterTypeSize[ins->mSType[0]] > 1)
+					block->mIns.Push(NativeCodeInstruction(ASMIT_ORA, ASMIM_ZERO_PAGE, BC_REG_TMP + iproc->mTempOffset[ins->mSTemp[0]] + 1));
 
 				block->Close(CompileBlock(iproc, iblock->mTrueJump), CompileBlock(iproc, iblock->mFalseJump), ASMIT_BNE);
 			}
diff --git a/oscar64/NativeCodeGenerator.h b/oscar64/NativeCodeGenerator.h
index c40ef322..e898a57f 100644
--- a/oscar64/NativeCodeGenerator.h
+++ b/oscar64/NativeCodeGenerator.h
@@ -83,25 +83,25 @@ class NativeCodeBasicBlock
 	void PutWord(uint16 code);
 
 	void CheckFrameIndex(int & reg, int & index, int size);
-	void LoadValueToReg(InterCodeProcedure* proc, const InterInstruction& ins, int reg, const NativeCodeInstruction * ainsl, const NativeCodeInstruction* ainsh);
-	void LoadConstantToReg(InterCodeProcedure* proc, const InterInstruction& ins, InterType type, int reg);
-
-	void LoadConstant(InterCodeProcedure* proc, const InterInstruction& ins);
-	void StoreValue(InterCodeProcedure* proc, const InterInstruction& ins);
-	void LoadValue(InterCodeProcedure* proc, const InterInstruction& ins);
-	void LoadStoreValue(InterCodeProcedure* proc, const InterInstruction& rins, const InterInstruction& wins);
-	void BinaryOperator(InterCodeProcedure* proc, const InterInstruction& ins, const InterInstruction* sins1, const InterInstruction* sins0);
-	void UnaryOperator(InterCodeProcedure* proc, const InterInstruction& ins);
-	void RelationalOperator(InterCodeProcedure* proc, const InterInstruction& ins, NativeCodeProcedure * nproc, NativeCodeBasicBlock* trueJump, NativeCodeBasicBlock * falseJump);
-	void LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction& ins, const InterInstruction* sins1, const InterInstruction* sins0);
-	void NumericConversion(InterCodeProcedure* proc, const InterInstruction& ins);
-	void CopyValue(InterCodeProcedure* proc, const InterInstruction& ins, NativeCodeProcedure* nproc);
-
-	void CallAssembler(InterCodeProcedure* proc, const InterInstruction& ins);
-	void CallFunction(InterCodeProcedure* proc, const InterInstruction& ins);
+	void LoadValueToReg(InterCodeProcedure* proc, const InterInstruction * ins, int reg, const NativeCodeInstruction * ainsl, const NativeCodeInstruction* ainsh);
+	void LoadConstantToReg(InterCodeProcedure* proc, const InterInstruction * ins, InterType type, int reg);
+
+	void LoadConstant(InterCodeProcedure* proc, const InterInstruction * ins);
+	void StoreValue(InterCodeProcedure* proc, const InterInstruction * ins);
+	void LoadValue(InterCodeProcedure* proc, const InterInstruction * ins);
+	void LoadStoreValue(InterCodeProcedure* proc, const InterInstruction * rins, const InterInstruction * wins);
+	void BinaryOperator(InterCodeProcedure* proc, const InterInstruction * ins, const InterInstruction* sins1, const InterInstruction* sins0);
+	void UnaryOperator(InterCodeProcedure* proc, const InterInstruction * ins);
+	void RelationalOperator(InterCodeProcedure* proc, const InterInstruction * ins, NativeCodeProcedure * nproc, NativeCodeBasicBlock* trueJump, NativeCodeBasicBlock * falseJump);
+	void LoadEffectiveAddress(InterCodeProcedure* proc, const InterInstruction * ins, const InterInstruction* sins1, const InterInstruction* sins0);
+	void NumericConversion(InterCodeProcedure* proc, const InterInstruction * ins);
+	void CopyValue(InterCodeProcedure* proc, const InterInstruction * ins, NativeCodeProcedure* nproc);
+
+	void CallAssembler(InterCodeProcedure* proc, const InterInstruction * ins);
+	void CallFunction(InterCodeProcedure* proc, const InterInstruction * ins);
 
 	void ShiftRegisterLeft(InterCodeProcedure* proc, int reg, int shift);
-	int ShortMultiply(InterCodeProcedure* proc, const InterInstruction& ins, const InterInstruction* sins, int index, int mul);
+	int ShortMultiply(InterCodeProcedure* proc, const InterInstruction * ins, const InterInstruction* sins, int index, int mul);
 
 	bool CheckPredAccuStore(int reg);
 
diff --git a/oscar64/NumberSet.h b/oscar64/NumberSet.h
index 54a07a7b..8e445cff 100644
--- a/oscar64/NumberSet.h
+++ b/oscar64/NumberSet.h
@@ -92,7 +92,7 @@ __forceinline bool FastNumberSet::operator[](int elem)
 {
 	uint32 dw = buffer[size + elem];
 
-	return (dw < num&& buffer[dw] == elem);
+	return (dw < num && buffer[dw] == elem);
 }
 
 __forceinline FastNumberSet& FastNumberSet::operator+=(int elem)