diff --git a/pcsx2/COP0.cpp b/pcsx2/COP0.cpp
index 4b3a45137e..7258ae0a63 100644
--- a/pcsx2/COP0.cpp
+++ b/pcsx2/COP0.cpp
@@ -47,16 +47,15 @@ void MapTLB(int i)
 	u32 mask, addr;
 	u32 saddr, eaddr;
 
-#ifndef PCSX2_VIRTUAL_MEM
 	DevCon::WriteLn("MAP TLB %d: %08x-> [%08x %08x] S=%d G=%d ASID=%d Mask= %03X", params
 		i,tlb[i].VPN2,tlb[i].PFN0,tlb[i].PFN1,tlb[i].S,tlb[i].G,tlb[i].ASID,tlb[i].Mask);
 
 	if (tlb[i].S)
 	{
-		SysPrintf("OMG SPRAM MAPPING %08X %08X\n",tlb[i].VPN2,tlb[i].Mask);
+		DevCon::WriteLn("OMG SPRAM MAPPING %08X %08X\n",params tlb[i].VPN2,tlb[i].Mask);
 		vtlb_VMapBuffer(tlb[i].VPN2,psS,0x4000);
 	}
-#endif
+
 	if (tlb[i].VPN2 == 0x70000000) return; //uh uhh right ...
 
 	if (tlb[i].EntryLo0 & 0x2) {
@@ -92,13 +91,11 @@ void UnmapTLB(int i)
 	u32 mask, addr;
 	u32 saddr, eaddr;
 
-#ifndef PCSX2_VIRTUAL_MEM
 	if (tlb[i].S)
 	{
 		vtlb_VMapUnmap(tlb[i].VPN2,0x4000);
 		return;
 	}
-#endif
 
 	if (tlb[i].EntryLo0 & 0x2) 
 	{
@@ -142,9 +139,8 @@ void WriteTLB(int i)
 	tlb[i].G = cpuRegs.CP0.n.EntryLo0 & cpuRegs.CP0.n.EntryLo1 & 0x1;
 	tlb[i].PFN0 = (((cpuRegs.CP0.n.EntryLo0 >> 6) & 0xFFFFF) & (~tlb[i].Mask)) << 12;
 	tlb[i].PFN1 = (((cpuRegs.CP0.n.EntryLo1 >> 6) & 0xFFFFF) & (~tlb[i].Mask)) << 12;
-#ifndef PCSX2_VIRTUAL_MEM
 	tlb[i].S = cpuRegs.CP0.n.EntryLo0&0x80000000;
-#endif
+
 	MapTLB(i);
 }
 
diff --git a/pcsx2/Counters.cpp b/pcsx2/Counters.cpp
index 749a1d46e1..252bdb7c94 100644
--- a/pcsx2/Counters.cpp
+++ b/pcsx2/Counters.cpp
@@ -852,16 +852,6 @@ void SaveState::rcntFreeze()
 	{
 		UpdateVSyncRate();
 
-#ifdef PCSX2_VIRTUAL_MEM
-		// Sanity check for loading older savestates:
-
-		if( counters[4].sCycle == 0 )
-			counters[4].sCycle = cpuRegs.cycle;
-
-		if( counters[5].sCycle == 0 )
-			counters[5].sCycle = cpuRegs.cycle;
-#endif
-	
 		// make sure the gate flags are set based on the counter modes...
 		for( int i=0; i<4; i++ )
 			_rcntSetGate( i );
diff --git a/pcsx2/GS.cpp b/pcsx2/GS.cpp
index 5e52ffa1dc..8bca035124 100644
--- a/pcsx2/GS.cpp
+++ b/pcsx2/GS.cpp
@@ -108,12 +108,8 @@ __forceinline void GSVSYNC(void) {
 
 u32 CSRw;
 
-#ifdef PCSX2_VIRTUAL_MEM
-#define PS2GS_BASE(mem) ((PS2MEM_BASE+0x12000000)+(mem&0x13ff))
-#else
 PCSX2_ALIGNED16( u8 g_RealGSMem[0x2000] );
 #define PS2GS_BASE(mem) (g_RealGSMem+(mem&0x13ff))
-#endif
 
 extern int m_nCounters[];
 
@@ -262,9 +258,7 @@ void gsReset()
 		UpdateVSyncRate() 
 	);
 
-#ifndef PCSX2_VIRTUAL_MEM
 	memzero_obj(g_RealGSMem);
-#endif
 
 	Path3transfer = 0;
 
@@ -298,10 +292,8 @@ bool gsGIFSoftReset( int mask )
 
 void gsGIFReset()
 {
-#ifndef PCSX2_VIRTUAL_MEM
 	// fixme - should this be here? (air)
 	//memzero_obj(g_RealGSMem);
-#endif
 
 	// perform a soft reset (but do not do a full reset if the soft reset API is unavailable)
 	gsGIFSoftReset( 7 );
diff --git a/pcsx2/GS.h b/pcsx2/GS.h
index 99fea910ff..6c77c7d2e7 100644
--- a/pcsx2/GS.h
+++ b/pcsx2/GS.h
@@ -30,16 +30,10 @@
 
 #define GSPATH3FIX
 
-#ifdef PCSX2_VIRTUAL_MEM
-#define GSCSRr *((u64*)(PS2MEM_GS+0x1000))
-#define GSIMR *((u32*)(PS2MEM_GS+0x1010))
-#define GSSIGLBLID ((GSRegSIGBLID*)(PS2MEM_GS+0x1080))
-#else
 PCSX2_ALIGNED16( extern u8 g_RealGSMem[0x2000] );
 #define GSCSRr *((u64*)(g_RealGSMem+0x1000))
 #define GSIMR *((u32*)(g_RealGSMem+0x1010))
 #define GSSIGLBLID ((GSRegSIGBLID*)(g_RealGSMem+0x1080))
-#endif
 
 /////////////////////////////////////////////////////////////////////////////
 // MTGS GIFtag Parser - Declaration
diff --git a/pcsx2/Gif.cpp b/pcsx2/Gif.cpp
index 193da5d8fe..3401b3c8b3 100644
--- a/pcsx2/Gif.cpp
+++ b/pcsx2/Gif.cpp
@@ -29,11 +29,7 @@
 using std::min;
 
 
-#ifdef PCSX2_VIRTUAL_MEM
-#define gif ((DMACh*)&PS2MEM_HW[0xA000])
-#else
 #define gif ((DMACh*)&psH[0xA000])
-#endif
 
 static u64 s_gstag=0; // used for querying the last tag
 static int gspath3done=0;
@@ -100,21 +96,6 @@ static void WRITERING_DMA(u32 *pMem, u32 qwc)
 		// fixed? PrepDataPacket now returns the actual size of the packet.
 		// VIF handles scratchpad wrapping also, so this code shouldn't be needed anymore.
 
-		//vm build still needs this, fixes Fatal Frame init(rama)
-
-#ifdef PCSX2_VIRTUAL_MEM  //only do this for vm build, vtlb is fine 
-		u32 pendmem = (u32)gif->madr + sizetoread; 
-		if( dmaGetAddr(pendmem-16) == NULL )
-		{ 
-			pendmem = ((pendmem-16)&~0xfff)-16; 
-			while(dmaGetAddr(pendmem) == NULL)
-			{ 
-				pendmem = (pendmem&~0xfff)-16; 
-			} 
-			memcpy_aligned(pgsmem, pMem, pendmem-(u32)gif->madr+16);
-		}
-		else
-#endif
 		memcpy_aligned(pgsmem, pMem, sizetoread<<4); 
 		
 		mtgsThread->SendDataPacket();
diff --git a/pcsx2/Hw.cpp b/pcsx2/Hw.cpp
index 9f30f32177..b06da188ff 100644
--- a/pcsx2/Hw.cpp
+++ b/pcsx2/Hw.cpp
@@ -35,9 +35,7 @@
 
 using namespace R5900;
 
-#ifndef PCSX2_VIRTUAL_MEM
 u8  *psH; // hw mem
-#endif
 
 int rdram_devices = 2;	// put 8 for TOOL and 2 for PS2 and PSX
 int rdram_sdevid = 0;
@@ -1367,7 +1365,7 @@ int hwDmacSrcChain(DMACh *dma, int id) {
 }
 
 // Original hwRead/Write32 functions .. left in for now, for troubleshooting purposes.
-#if 1
+#if 0
 mem32_t __fastcall hwRead32(u32 mem)
 {
 	// *Performance Warning*  This function is called -A-LOT.  Be weary when making changes.  It
@@ -1811,14 +1809,10 @@ __forceinline void __fastcall hwWrite32(u32 mem, u32 value)
 			break;
 //------------------------------------------------------------------
 		default:
-#ifndef PCSX2_VIRTUAL_MEM
-			if (mem < 0x10010000)
-#endif
-			{
-				psHu32(mem) = value;
-			}
+			psHu32(mem) = value;
 			HW_LOG("Unknown Hardware write 32 at %x with value %x (%x)\n", mem, value, cpuRegs.CP0.n.Status.val);
 		break;
 	}
 }
-#endif
\ No newline at end of file
+#endif
+
diff --git a/pcsx2/Hw.h b/pcsx2/Hw.h
index b25ab47452..4e2d4e30b4 100644
--- a/pcsx2/Hw.h
+++ b/pcsx2/Hw.h
@@ -19,9 +19,7 @@
 #ifndef __HW_H__
 #define __HW_H__
 
-#ifndef PCSX2_VIRTUAL_MEM
 extern u8  *psH; // hw mem
-#endif
 
 #define psHs8(mem)	(*(s8 *)&PS2MEM_HW[(mem) & 0xffff])
 #define psHs16(mem)	(*(s16*)&PS2MEM_HW[(mem) & 0xffff])
@@ -308,6 +306,7 @@ struct DMACh {
 extern PSMEMORYMAP* memLUT;
 #endif
 
+// VM-version of dmaGetAddr -- Left in for references purposes for now (air)
 static __forceinline u8* dmaGetAddr(u32 mem)
 {
 	u8* p, *pbase;
@@ -414,10 +413,6 @@ void hwConstWrite32(u32 mem, int mmreg);
 void hwConstWrite64(u32 mem, int mmreg);
 void hwConstWrite128(u32 mem, int xmmreg);
 
-#ifdef PCSX2_VIRTUAL_MEM
-void iMemRead32Check();
-#endif
-
 extern void  intcInterrupt();
 extern void  dmacInterrupt();
 
diff --git a/pcsx2/IPU/IPU.cpp b/pcsx2/IPU/IPU.cpp
index ebf9a75803..4a9f6db7d5 100644
--- a/pcsx2/IPU/IPU.cpp
+++ b/pcsx2/IPU/IPU.cpp
@@ -48,9 +48,7 @@ using namespace std;			// for min / max
 #	define IPU_FORCEINLINE __forceinline
 #endif
 
-#ifndef PCSX2_VIRTUAL_MEM
-IPUregisters g_ipuRegsReal;
-#endif
+//IPUregisters g_ipuRegsReal;
 
 #define ipu0dma ((DMACh *)&PS2MEM_HW[0xb000])
 #define ipu1dma ((DMACh *)&PS2MEM_HW[0xb400])
diff --git a/pcsx2/IopCounters.cpp b/pcsx2/IopCounters.cpp
index 613da24b2d..1fef737555 100644
--- a/pcsx2/IopCounters.cpp
+++ b/pcsx2/IopCounters.cpp
@@ -720,58 +720,7 @@ u64 psxRcntCycles(int index)
 
 void SaveState::psxRcntFreeze()
 {
-#ifdef PCSX2_VIRTUAL_MEM
-	if( IsLoading() && (GetVersion() < 0x10) )
-	{
-		// --- Reading Mode, Old Version ---
-		// struct used to be 32bit count and target
-		int i;
-		u32 val;
-		for(i = 0; i < ARRAYSIZE(psxCounters); ++i)
-		{
-			Freeze(val); psxCounters[i].count = val;
-			Freeze(val); psxCounters[i].mode = val;
-			Freeze(val); psxCounters[i].target = val;
-			FreezeMem((u8*)&psxCounters[i].rate, sizeof(psxCounters[i])-20);
-		}
-	}
-    else
-	{
-	    Freeze(psxCounters);
-
-		// new in v.11
-		if( GetVersion() > 0x10 )
-		{
-			Freeze(psxNextCounter);
-			Freeze(psxNextsCounter);
-		}
-	}
-
-	if( IsLoading() && (GetVersion() <= 0x10) )
-	{
-		psxNextCounter = 0;
-		psxNextsCounter = psxRegs.cycle;
-
-		// This is needed to make old save states compatible.
-		psxCounters[6].rate = 768*12;
-		psxCounters[6].CycleT = psxCounters[6].rate;
-		psxCounters[7].rate = PSXCLK/1000;
-		psxCounters[7].CycleT = psxCounters[7].rate;	
-		
-		// PSXHBLANK is now an arbitrary value, since it can differ based 
-		// on PAL/NTSC and is timed by the EE.
-		if(psxCounters[1].mode & IOPCNT_ALT_SOURCE)
-			psxCounters[1].rate = PSXHBLANK;
-
-		if(psxCounters[3].mode & IOPCNT_ALT_SOURCE)
-			psxCounters[3].rate = PSXHBLANK;
-	}
-#else
-
-	// vTLB's new savestate version! :D
-
     Freeze(psxCounters);
 	Freeze(psxNextCounter);
 	Freeze(psxNextsCounter);
-#endif
 }
diff --git a/pcsx2/IopMem.h b/pcsx2/IopMem.h
index d6ab300c85..cb9498c42d 100644
--- a/pcsx2/IopMem.h
+++ b/pcsx2/IopMem.h
@@ -19,18 +19,6 @@
 #ifndef __PSXMEMORY_H__
 #define __PSXMEMORY_H__
 
-#ifdef PCSX2_VIRTUAL_MEM
-
-// VM
-#define psxM PS2MEM_PSX
-#define psxH PS2MEM_PSXHW
-
-#define PSXM(mem) ((mem&0x10000000)?PSM(mem):(PS2MEM_PSX+(mem&0x1fffff)))
-#define _PSXM(mem) PSXM(mem)
-
-#else
-
-// TLB
 extern u8 *psxM;
 extern u8 *psxP;
 extern u8 *psxH;
@@ -38,7 +26,6 @@ extern u8 *psxS;
 extern uptr *psxMemWLUT;
 extern const uptr *psxMemRLUT;
 
-//#define TLB_DEBUG_MEM
 #ifdef TLB_DEBUG_MEM
 void* PSXM(u32 mem);
 void* _PSXM(u32 mem);
@@ -54,8 +41,6 @@ void* _PSXM(u32 mem);
 #define psxSu16(mem)	(*(u16*)&psxS[(mem) & 0xffff])
 #define psxSu32(mem)	(*(u32*)&psxS[(mem) & 0xffff])
 
-#endif
-
 #define psxMs8(mem)		psxM[(mem) & 0x1fffff]
 #define psxMs16(mem)	(*(s16*)&psxM[(mem) & 0x1fffff])
 #define psxMs32(mem)	(*(s32*)&psxM[(mem) & 0x1fffff])
diff --git a/pcsx2/Memory.cpp b/pcsx2/Memory.cpp
index 0e8a98971e..433ce19b86 100644
--- a/pcsx2/Memory.cpp
+++ b/pcsx2/Memory.cpp
@@ -130,8 +130,6 @@ void loadBiosRom( const char *ext, u8 *dest, long maxSize )
 	fclose(fp);
 }
 
-#ifndef PCSX2_VIRTUAL_MEM
-
 u32 psMPWC[(Ps2MemSize::Base/32)>>12];
 std::vector<u32> psMPWVA[Ps2MemSize::Base>>12];
 
@@ -907,5 +905,3 @@ __forceinline void __fastcall SysPageFaultExceptionFilter( int signal, siginfo_t
 	psMPWVA[offset].clear();
 }
 #endif
-
-#endif
diff --git a/pcsx2/Memory.h b/pcsx2/Memory.h
index 1064e247b3..8f3d58ca12 100644
--- a/pcsx2/Memory.h
+++ b/pcsx2/Memory.h
@@ -45,6 +45,163 @@ namespace Ps2MemSize
 	static const uint GSregs = 0x00002000;		// 8k for the GS registers and stuff.
 }
 
+extern u8  *psM; //32mb Main Ram
+extern u8  *psR; //4mb rom area
+extern u8  *psR1; //256kb rom1 area (actually 196kb, but can't mask this)
+extern u8  *psR2; // 0x00080000
+extern u8  *psER; // 0x001C0000
+extern u8  *psS; //0.015 mb, scratch pad
+
+#define PS2MEM_BASE		psM
+#define PS2MEM_HW		psH
+#define PS2MEM_ROM		psR
+#define PS2MEM_ROM1		psR1
+#define PS2MEM_ROM2		psR2
+#define PS2MEM_EROM		psER
+#define PS2MEM_SCRATCH	psS
+
+extern u8 g_RealGSMem[0x2000];
+#define PS2MEM_GS	g_RealGSMem
+
+//#define _PSM(mem)	(memLUTR[(mem) >> 12] == 0 ? NULL : (void*)(memLUTR[(mem) >> 12] + ((mem) & 0xfff)))
+#define PSM(mem)	(vtlb_GetPhyPtr(mem&0x1fffffff)) //pcsx2 is a competition.The one with most hacks wins :D
+#define FREE(ptr) _aligned_free(ptr)
+
+#define psMs8(mem)	(*(s8 *)&PS2MEM_BASE[(mem) & 0x1ffffff])
+#define psMs16(mem)	(*(s16*)&PS2MEM_BASE[(mem) & 0x1ffffff])
+#define psMs32(mem)	(*(s32*)&PS2MEM_BASE[(mem) & 0x1ffffff])
+#define psMs64(mem)	(*(s64*)&PS2MEM_BASE[(mem) & 0x1ffffff])
+#define psMu8(mem)	(*(u8 *)&PS2MEM_BASE[(mem) & 0x1ffffff])
+#define psMu16(mem)	(*(u16*)&PS2MEM_BASE[(mem) & 0x1ffffff])
+#define psMu32(mem)	(*(u32*)&PS2MEM_BASE[(mem) & 0x1ffffff])
+#define psMu64(mem)	(*(u64*)&PS2MEM_BASE[(mem) & 0x1ffffff])
+
+#define psRs8(mem)	(*(s8 *)&PS2MEM_ROM[(mem) & 0x3fffff])
+#define psRs16(mem)	(*(s16*)&PS2MEM_ROM[(mem) & 0x3fffff])
+#define psRs32(mem)	(*(s32*)&PS2MEM_ROM[(mem) & 0x3fffff])
+#define psRs64(mem)	(*(s64*)&PS2MEM_ROM[(mem) & 0x3fffff])
+#define psRu8(mem)	(*(u8 *)&PS2MEM_ROM[(mem) & 0x3fffff])
+#define psRu16(mem)	(*(u16*)&PS2MEM_ROM[(mem) & 0x3fffff])
+#define psRu32(mem)	(*(u32*)&PS2MEM_ROM[(mem) & 0x3fffff])
+#define psRu64(mem)	(*(u64*)&PS2MEM_ROM[(mem) & 0x3fffff])
+
+#define psR1s8(mem)		(*(s8 *)&PS2MEM_ROM1[(mem) & 0x3ffff])
+#define psR1s16(mem)	(*(s16*)&PS2MEM_ROM1[(mem) & 0x3ffff])
+#define psR1s32(mem)	(*(s32*)&PS2MEM_ROM1[(mem) & 0x3ffff])
+#define psR1s64(mem)	(*(s64*)&PS2MEM_ROM1[(mem) & 0x3ffff])
+#define psR1u8(mem)		(*(u8 *)&PS2MEM_ROM1[(mem) & 0x3ffff])
+#define psR1u16(mem)	(*(u16*)&PS2MEM_ROM1[(mem) & 0x3ffff])
+#define psR1u32(mem)	(*(u32*)&PS2MEM_ROM1[(mem) & 0x3ffff])
+#define psR1u64(mem)	(*(u64*)&PS2MEM_ROM1[(mem) & 0x3ffff])
+
+#define psR2s8(mem)		(*(s8 *)&PS2MEM_ROM2[(mem) & 0x3ffff])
+#define psR2s16(mem)	(*(s16*)&PS2MEM_ROM2[(mem) & 0x3ffff])
+#define psR2s32(mem)	(*(s32*)&PS2MEM_ROM2[(mem) & 0x3ffff])
+#define psR2s64(mem)	(*(s64*)&PS2MEM_ROM2[(mem) & 0x3ffff])
+#define psR2u8(mem)		(*(u8 *)&PS2MEM_ROM2[(mem) & 0x3ffff])
+#define psR2u16(mem)	(*(u16*)&PS2MEM_ROM2[(mem) & 0x3ffff])
+#define psR2u32(mem)	(*(u32*)&PS2MEM_ROM2[(mem) & 0x3ffff])
+#define psR2u64(mem)	(*(u64*)&PS2MEM_ROM2[(mem) & 0x3ffff])
+
+#define psERs8(mem)		(*(s8 *)&PS2MEM_EROM[(mem) & 0x3ffff])
+#define psERs16(mem)	(*(s16*)&PS2MEM_EROM[(mem) & 0x3ffff])
+#define psERs32(mem)	(*(s32*)&PS2MEM_EROM[(mem) & 0x3ffff])
+#define psERs64(mem)	(*(s64*)&PS2MEM_EROM[(mem) & 0x3ffff])
+#define psERu8(mem)		(*(u8 *)&PS2MEM_EROM[(mem) & 0x3ffff])
+#define psERu16(mem)	(*(u16*)&PS2MEM_EROM[(mem) & 0x3ffff])
+#define psERu32(mem)	(*(u32*)&PS2MEM_EROM[(mem) & 0x3ffff])
+#define psERu64(mem)	(*(u64*)&PS2MEM_EROM[(mem) & 0x3ffff])
+
+#define psSs8(mem)	(*(s8 *)&PS2MEM_SCRATCH[(mem) & 0x3fff])
+#define psSs16(mem)	(*(s16*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
+#define psSs32(mem)	(*(s32*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
+#define psSs64(mem)	(*(s64*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
+#define psSu8(mem)	(*(u8 *)&PS2MEM_SCRATCH[(mem) & 0x3fff])
+#define psSu16(mem)	(*(u16*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
+#define psSu32(mem)	(*(u32*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
+#define psSu64(mem)	(*(u64*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
+
+#define PSMs8(mem)	(*(s8 *)PSM(mem))
+#define PSMs16(mem)	(*(s16*)PSM(mem))
+#define PSMs32(mem)	(*(s32*)PSM(mem))
+#define PSMs64(mem)	(*(s64*)PSM(mem))
+#define PSMu8(mem)	(*(u8 *)PSM(mem))
+#define PSMu16(mem)	(*(u16*)PSM(mem))
+#define PSMu32(mem)	(*(u32*)PSM(mem))
+#define PSMu64(mem)	(*(u64*)PSM(mem))
+
+extern void memAlloc();
+extern void memReset();		// clears PS2 ram and loads the bios.  Throws Exception::FileNotFound on error.
+extern void memShutdown();
+extern void memSetKernelMode();
+extern void memSetSupervisorMode();
+extern void memSetUserMode();
+extern void memSetPageAddr(u32 vaddr, u32 paddr);
+extern void memClearPageAddr(u32 vaddr);
+
+extern void memMapVUmicro();
+
+#ifdef __LINUX__
+void SysPageFaultExceptionFilter( int signal, siginfo_t *info, void * );
+void __fastcall InstallLinuxExceptionHandler();
+void __fastcall ReleaseLinuxExceptionHandler();
+#else
+int SysPageFaultExceptionFilter(EXCEPTION_POINTERS* eps);
+#endif
+
+#include "vtlb.h"
+
+int mmap_GetRamPageInfo(void* ptr);
+void mmap_MarkCountedRamPage(void* ptr,u32 vaddr);
+void mmap_ResetBlockTracking();
+
+extern void __fastcall memRead8(u32 mem, u8  *out);
+extern void __fastcall memRead16(u32 mem, u16 *out);
+extern void __fastcall memRead32(u32 mem, u32 *out);
+
+#define memRead64 vtlb_memRead64
+#define memRead128 vtlb_memRead128
+
+#define memWrite8 vtlb_memWrite8
+#define memWrite16 vtlb_memWrite16
+#define memWrite32 vtlb_memWrite32
+#define memWrite64 vtlb_memWrite64
+#define memWrite128 vtlb_memWrite128
+
+#define _eeReadConstMem8 0&&
+#define _eeReadConstMem16 0&&
+#define _eeReadConstMem32 0&&
+#define _eeReadConstMem128 0&&
+#define _eeWriteConstMem8 0&&
+#define _eeWriteConstMem16 0&&
+#define _eeWriteConstMem32 0&&
+#define _eeWriteConstMem64 0&&
+#define _eeWriteConstMem128 0&&
+#define _eeMoveMMREGtoR 0&&
+
+// extra ops
+#define _eeWriteConstMem16OP 0&&
+#define _eeWriteConstMem32OP 0&&
+
+#define recMemConstRead8 0&&
+#define recMemConstRead16 0&&
+#define recMemConstRead32 0&&
+#define recMemConstRead64 0&&
+#define recMemConstRead128 0&&
+
+#define recMemConstWrite8 0&&
+#define recMemConstWrite16 0&&
+#define recMemConstWrite32 0&&
+#define recMemConstWrite64 0&&
+#define recMemConstWrite128 0&&
+
+extern void loadBiosRom( const char *ext, u8 *dest, long maxSize );
+extern u16 ba0R16(u32 mem);
+
+//////////////////////////////////////////////////////////////////////////
+// The rest of this header contains the old VM version of the Memory.h API.
+// Left in for references purposes.
+
 #ifdef PCSX2_VIRTUAL_MEM
 
 #define PS2MEM_BASE_	0x15000000
@@ -142,163 +299,6 @@ int recMemConstWrite16(u32 mem, int mmreg);
 int recMemConstWrite32(u32 mem, int mmreg);
 int recMemConstWrite64(u32 mem, int mmreg);
 int recMemConstWrite128(u32 mem, int xmmreg);
-
-#else
-
-extern u8  *psM; //32mb Main Ram
-extern u8  *psR; //4mb rom area
-extern u8  *psR1; //256kb rom1 area (actually 196kb, but can't mask this)
-extern u8  *psR2; // 0x00080000
-extern u8  *psER; // 0x001C0000
-extern u8  *psS; //0.015 mb, scratch pad
-
-#define PS2MEM_BASE		psM
-#define PS2MEM_HW		psH
-#define PS2MEM_ROM		psR
-#define PS2MEM_ROM1		psR1
-#define PS2MEM_ROM2		psR2
-#define PS2MEM_EROM		psER
-#define PS2MEM_SCRATCH	psS
-
-extern u8 g_RealGSMem[0x2000];
-#define PS2MEM_GS	g_RealGSMem
-
-//#define _PSM(mem)	(memLUTR[(mem) >> 12] == 0 ? NULL : (void*)(memLUTR[(mem) >> 12] + ((mem) & 0xfff)))
-#define PSM(mem)	(vtlb_GetPhyPtr(mem&0x1fffffff)) //pcsx2 is a competition.The one with most hacks wins :D
-#define FREE(ptr) _aligned_free(ptr)
-
 #endif
 
-#define psMs8(mem)	(*(s8 *)&PS2MEM_BASE[(mem) & 0x1ffffff])
-#define psMs16(mem)	(*(s16*)&PS2MEM_BASE[(mem) & 0x1ffffff])
-#define psMs32(mem)	(*(s32*)&PS2MEM_BASE[(mem) & 0x1ffffff])
-#define psMs64(mem)	(*(s64*)&PS2MEM_BASE[(mem) & 0x1ffffff])
-#define psMu8(mem)	(*(u8 *)&PS2MEM_BASE[(mem) & 0x1ffffff])
-#define psMu16(mem)	(*(u16*)&PS2MEM_BASE[(mem) & 0x1ffffff])
-#define psMu32(mem)	(*(u32*)&PS2MEM_BASE[(mem) & 0x1ffffff])
-#define psMu64(mem)	(*(u64*)&PS2MEM_BASE[(mem) & 0x1ffffff])
-
-#define psRs8(mem)	(*(s8 *)&PS2MEM_ROM[(mem) & 0x3fffff])
-#define psRs16(mem)	(*(s16*)&PS2MEM_ROM[(mem) & 0x3fffff])
-#define psRs32(mem)	(*(s32*)&PS2MEM_ROM[(mem) & 0x3fffff])
-#define psRs64(mem)	(*(s64*)&PS2MEM_ROM[(mem) & 0x3fffff])
-#define psRu8(mem)	(*(u8 *)&PS2MEM_ROM[(mem) & 0x3fffff])
-#define psRu16(mem)	(*(u16*)&PS2MEM_ROM[(mem) & 0x3fffff])
-#define psRu32(mem)	(*(u32*)&PS2MEM_ROM[(mem) & 0x3fffff])
-#define psRu64(mem)	(*(u64*)&PS2MEM_ROM[(mem) & 0x3fffff])
-
-#define psR1s8(mem)		(*(s8 *)&PS2MEM_ROM1[(mem) & 0x3ffff])
-#define psR1s16(mem)	(*(s16*)&PS2MEM_ROM1[(mem) & 0x3ffff])
-#define psR1s32(mem)	(*(s32*)&PS2MEM_ROM1[(mem) & 0x3ffff])
-#define psR1s64(mem)	(*(s64*)&PS2MEM_ROM1[(mem) & 0x3ffff])
-#define psR1u8(mem)		(*(u8 *)&PS2MEM_ROM1[(mem) & 0x3ffff])
-#define psR1u16(mem)	(*(u16*)&PS2MEM_ROM1[(mem) & 0x3ffff])
-#define psR1u32(mem)	(*(u32*)&PS2MEM_ROM1[(mem) & 0x3ffff])
-#define psR1u64(mem)	(*(u64*)&PS2MEM_ROM1[(mem) & 0x3ffff])
-
-#define psR2s8(mem)		(*(s8 *)&PS2MEM_ROM2[(mem) & 0x3ffff])
-#define psR2s16(mem)	(*(s16*)&PS2MEM_ROM2[(mem) & 0x3ffff])
-#define psR2s32(mem)	(*(s32*)&PS2MEM_ROM2[(mem) & 0x3ffff])
-#define psR2s64(mem)	(*(s64*)&PS2MEM_ROM2[(mem) & 0x3ffff])
-#define psR2u8(mem)		(*(u8 *)&PS2MEM_ROM2[(mem) & 0x3ffff])
-#define psR2u16(mem)	(*(u16*)&PS2MEM_ROM2[(mem) & 0x3ffff])
-#define psR2u32(mem)	(*(u32*)&PS2MEM_ROM2[(mem) & 0x3ffff])
-#define psR2u64(mem)	(*(u64*)&PS2MEM_ROM2[(mem) & 0x3ffff])
-
-#define psERs8(mem)		(*(s8 *)&PS2MEM_EROM[(mem) & 0x3ffff])
-#define psERs16(mem)	(*(s16*)&PS2MEM_EROM[(mem) & 0x3ffff])
-#define psERs32(mem)	(*(s32*)&PS2MEM_EROM[(mem) & 0x3ffff])
-#define psERs64(mem)	(*(s64*)&PS2MEM_EROM[(mem) & 0x3ffff])
-#define psERu8(mem)		(*(u8 *)&PS2MEM_EROM[(mem) & 0x3ffff])
-#define psERu16(mem)	(*(u16*)&PS2MEM_EROM[(mem) & 0x3ffff])
-#define psERu32(mem)	(*(u32*)&PS2MEM_EROM[(mem) & 0x3ffff])
-#define psERu64(mem)	(*(u64*)&PS2MEM_EROM[(mem) & 0x3ffff])
-
-#define psSs8(mem)	(*(s8 *)&PS2MEM_SCRATCH[(mem) & 0x3fff])
-#define psSs16(mem)	(*(s16*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
-#define psSs32(mem)	(*(s32*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
-#define psSs64(mem)	(*(s64*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
-#define psSu8(mem)	(*(u8 *)&PS2MEM_SCRATCH[(mem) & 0x3fff])
-#define psSu16(mem)	(*(u16*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
-#define psSu32(mem)	(*(u32*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
-#define psSu64(mem)	(*(u64*)&PS2MEM_SCRATCH[(mem) & 0x3fff])
-
-#define PSMs8(mem)	(*(s8 *)PSM(mem))
-#define PSMs16(mem)	(*(s16*)PSM(mem))
-#define PSMs32(mem)	(*(s32*)PSM(mem))
-#define PSMs64(mem)	(*(s64*)PSM(mem))
-#define PSMu8(mem)	(*(u8 *)PSM(mem))
-#define PSMu16(mem)	(*(u16*)PSM(mem))
-#define PSMu32(mem)	(*(u32*)PSM(mem))
-#define PSMu64(mem)	(*(u64*)PSM(mem))
-
-extern void memAlloc();
-extern void memReset();		// clears PS2 ram and loads the bios.  Throws Exception::FileNotFound on error.
-extern void memShutdown();
-extern void memSetKernelMode();
-extern void memSetSupervisorMode();
-extern void memSetUserMode();
-extern void memSetPageAddr(u32 vaddr, u32 paddr);
-extern void memClearPageAddr(u32 vaddr);
-
-extern void memMapVUmicro();
-
-#ifdef __LINUX__
-void SysPageFaultExceptionFilter( int signal, siginfo_t *info, void * );
-void __fastcall InstallLinuxExceptionHandler();
-void __fastcall ReleaseLinuxExceptionHandler();
-#else
-int SysPageFaultExceptionFilter(EXCEPTION_POINTERS* eps);
-#endif
-
-#ifndef PCSX2_VIRTUAL_MEM
-#include "vtlb.h"
-
-int mmap_GetRamPageInfo(void* ptr);
-void mmap_MarkCountedRamPage(void* ptr,u32 vaddr);
-void mmap_ResetBlockTracking();
-
-extern void __fastcall memRead8(u32 mem, u8  *out);
-extern void __fastcall memRead16(u32 mem, u16 *out);
-extern void __fastcall memRead32(u32 mem, u32 *out);
-
-#define memRead64 vtlb_memRead64
-#define memRead128 vtlb_memRead128
-
-#define memWrite8 vtlb_memWrite8
-#define memWrite16 vtlb_memWrite16
-#define memWrite32 vtlb_memWrite32
-#define memWrite64 vtlb_memWrite64
-#define memWrite128 vtlb_memWrite128
-
-#define _eeReadConstMem8 0&&
-#define _eeReadConstMem16 0&&
-#define _eeReadConstMem32 0&&
-#define _eeReadConstMem128 0&&
-#define _eeWriteConstMem8 0&&
-#define _eeWriteConstMem16 0&&
-#define _eeWriteConstMem32 0&&
-#define _eeWriteConstMem64 0&&
-#define _eeWriteConstMem128 0&&
-#define _eeMoveMMREGtoR 0&&
-
-// extra ops
-#define _eeWriteConstMem16OP 0&&
-#define _eeWriteConstMem32OP 0&&
-
-#define recMemConstRead8 0&&
-#define recMemConstRead16 0&&
-#define recMemConstRead32 0&&
-#define recMemConstRead64 0&&
-#define recMemConstRead128 0&&
-
-#define recMemConstWrite8 0&&
-#define recMemConstWrite16 0&&
-#define recMemConstWrite32 0&&
-#define recMemConstWrite64 0&&
-#define recMemConstWrite128 0&&
-#endif
-
-extern void loadBiosRom( const char *ext, u8 *dest, long maxSize );
-extern u16 ba0R16(u32 mem);
 #endif
diff --git a/pcsx2/R5900.h b/pcsx2/R5900.h
index 0a86796435..0d8036a383 100644
--- a/pcsx2/R5900.h
+++ b/pcsx2/R5900.h
@@ -146,9 +146,7 @@ struct tlbs
 	u32 VPN2;
 	u32 PFN0;
 	u32 PFN1;
-#ifndef PCSX2_VIRTUAL_MEM
 	u32 S;
-#endif
 };
 
 #ifndef _PC_
diff --git a/pcsx2/SaveState.cpp b/pcsx2/SaveState.cpp
index 3e0431aba8..9ffba35c58 100644
--- a/pcsx2/SaveState.cpp
+++ b/pcsx2/SaveState.cpp
@@ -44,28 +44,11 @@ extern void recResetIOP();
 static void PreLoadPrep()
 {
 	SysResetExecutionState();
-
-#ifdef PCSX2_VIRTUAL_MEM
-	DWORD OldProtect;
-	// make sure can write
-	VirtualProtect(PS2MEM_ROM, 0x00400000, PAGE_READWRITE, &OldProtect);
-	VirtualProtect(PS2MEM_ROM1, 0x00040000, PAGE_READWRITE, &OldProtect);
-	VirtualProtect(PS2MEM_ROM2, 0x00080000, PAGE_READWRITE, &OldProtect);
-	VirtualProtect(PS2MEM_EROM, 0x001C0000, PAGE_READWRITE, &OldProtect);
-#endif
 }
 
 static void PostLoadPrep()
 {
-#ifdef PCSX2_VIRTUAL_MEM
-	DWORD OldProtect;
-	VirtualProtect(PS2MEM_ROM, 0x00400000, PAGE_READONLY, &OldProtect);
-	VirtualProtect(PS2MEM_ROM1, 0x00040000, PAGE_READONLY, &OldProtect);
-	VirtualProtect(PS2MEM_ROM2, 0x00080000, PAGE_READONLY, &OldProtect);
-	VirtualProtect(PS2MEM_EROM, 0x001C0000, PAGE_READONLY, &OldProtect);
-#endif
-
-	memset(pCache,0,sizeof(pCache));
+	memzero_obj(pCache);
 //	WriteCP0Status(cpuRegs.CP0.n.Status.val);
 	for(int i=0; i<48; i++) MapTLB(i);
 }
@@ -114,12 +97,6 @@ void SaveState::FreezeAll()
 	if( IsLoading() )
 		PreLoadPrep();
 
-#ifdef PCSX2_VIRTUAL_MEM
-	// VM Builds require the exception handler during memInit/Reset operations and
-	// during the savestate load/save code.
-	PCSX2_MEM_PROTECT_BEGIN();
-#endif
-
 	FreezeMem(PS2MEM_BASE, Ps2MemSize::Base);	// 32 MB main memory   
 	FreezeMem(PS2MEM_ROM, Ps2MemSize::Rom);		// 4 mb rom memory
 	FreezeMem(PS2MEM_ROM1, Ps2MemSize::Rom1);	// 256kb rom1 memory
@@ -169,10 +146,6 @@ void SaveState::FreezeAll()
 	FreezePlugin( "DEV9", DEV9freeze );
 	FreezePlugin( "USB", USBfreeze );
 
-#ifdef PCSX2_VIRTUAL_MEM
-	PCSX2_MEM_PROTECT_END();
-#endif
-
 	if( IsLoading() )
 		PostLoadPrep();
 }
@@ -231,15 +204,6 @@ gzLoadingState::gzLoadingState( const string& filename ) :
 
 	if( m_version != g_SaveVersion )
 	{
-#ifdef PCSX2_VIRTUAL_MEM
-		if( m_version >= 0x8b400000 )
-		{
-			throw Exception::UnsupportedStateVersion( m_version, "VM edition cannot safely load savestates created by the VTLB edition." );
-		}
-		// pcsx2 vm supports opening these formats
-		if( m_version < 0x7a30000d )
-			throw Exception::UnsupportedStateVersion( m_version );
-#else
 		if( ( m_version >> 16 ) == 0x7a30 )
 		{
 			Console::Error(
@@ -247,7 +211,6 @@ gzLoadingState::gzLoadingState( const string& filename ) :
 				"\tVTLB edition cannot safely load savestates created by the VM edition." );
 			throw Exception::UnsupportedStateVersion( m_version );
 		}
-#endif
 	}
 
 	_testCdvdCrc();
diff --git a/pcsx2/SaveState.h b/pcsx2/SaveState.h
index 3accf21ad2..325567630f 100644
--- a/pcsx2/SaveState.h
+++ b/pcsx2/SaveState.h
@@ -29,11 +29,7 @@
 // Savestate Versioning!
 //  If you make changes to the savestate version, please increment the value below.
 
-#ifdef PCSX2_VIRTUAL_MEM
-static const u32 g_SaveVersion = 0x7a300012;
-#else
 static const u32 g_SaveVersion = 0x8b400002;
-#endif
 
 // this function is meant to be sued in the place of GSfreeze, and provides a safe layer
 // between the GS saving function and the MTGS's needs. :)
@@ -59,12 +55,8 @@ public:
 	// The version refers to the low 16 bits only (high 16 bits classifies Pcsx2 build types)
 	u32 GetVersion() const
 	{
-#ifdef PCSX2_VIRTUAL_MEM
-		return m_version & 0xffff;
-#else
 		// HACK!  Matches the vTLB build versions with VM
 		return (m_version & 0xffff) + 0x10;
-#endif
 	}
 
 	// Loads or saves the entire emulation state.
diff --git a/pcsx2/System.cpp b/pcsx2/System.cpp
index cc63a9ec21..9f110f49f3 100644
--- a/pcsx2/System.cpp
+++ b/pcsx2/System.cpp
@@ -175,37 +175,8 @@ bool SysAllocateMem()
 		// completely non-functional.  If the failure is in the VM build then we can try running
 		// the VTLB build instead.  If it's the VTLB build then ... ouch.
 
-#ifdef PCSX2_VIRTUAL_MEM
-		Console::Error( ex.cMessage() );
-		if( MessageBox(NULL,
-			"Failed to allocate enough physical memory to run pcsx2. Try closing\n"
-			"down background programs, restarting windows, or buying more memory.\n\n"
-			"Launch TLB version of pcsx2 (pcsx2t.exe)?", "Memory Allocation Error", MB_YESNO) == IDYES )
-		{
-			PROCESS_INFORMATION pi;
-			STARTUPINFO si;
-
-			MemoryAlloc<char> strdir( GetCurrentDirectory( 0, NULL )+2, "VTLB Launcher" );
-			string strexe;
-
-			GetCurrentDirectory(strdir.GetLength(), strdir.GetPtr());
-			Path::Combine( strexe, strdir.GetPtr(), "pcsx2-vtlb.exe" );
-			memset(&si, 0, sizeof(si));
-
-			if( !CreateProcess(strexe.c_str(), "", NULL, NULL, FALSE, DETACHED_PROCESS|CREATE_NEW_PROCESS_GROUP, NULL, strdir.GetPtr(), &si, &pi))
-			{
-				MessageBox(NULL, fmt_string( "Failed to launch %hs\n", &strexe ).c_str(), "Failure", MB_OK);
-			}
-			else
-			{
-				CloseHandle(pi.hProcess);
-				CloseHandle(pi.hThread);
-			}
-		}
-#else
 		// VTLB build must fail outright...
 		Msgbox::Alert( "Failed to allocate memory needed to run pcsx2.\n\nError: %s", params ex.cMessage() );
-#endif
 		SysShutdownMem();
 
 		return false;
diff --git a/pcsx2/System.h b/pcsx2/System.h
index 94fa633dcf..259a6294b3 100644
--- a/pcsx2/System.h
+++ b/pcsx2/System.h
@@ -210,32 +210,4 @@ using Console::Color_White;
 
 #endif
 
-#ifdef PCSX2_VIRTUAL_MEM
-
-struct PSMEMORYBLOCK
-{
-#ifdef _WIN32
-    int NumberPages;
-	uptr* aPFNs;
-	uptr* aVFNs; // virtual pages that own the physical pages
-#else
-    int fd; // file descriptor
-    char* pname; // given name
-    int size; // size of allocated region
-#endif
-};
-
-int SysPhysicalAlloc(u32 size, PSMEMORYBLOCK* pblock);
-void SysPhysicalFree(PSMEMORYBLOCK* pblock);
-int SysVirtualPhyAlloc(void* base, u32 size, PSMEMORYBLOCK* pblock);
-void SysVirtualFree(void* lpMemReserved, u32 size);
-
-// returns 1 if successful, 0 otherwise
-int SysMapUserPhysicalPages(void* Addr, uptr NumPages, uptr* pblock, int pageoffset);
-
-// call to enable physical page allocation
-//BOOL SysLoggedSetLockPagesPrivilege ( HANDLE hProcess, BOOL bEnable);
-
-#endif
-
 #endif /* __SYSTEM_H__ */
diff --git a/pcsx2/VU1micro.cpp b/pcsx2/VU1micro.cpp
index d76c768e6d..dcf8a2dc2f 100644
--- a/pcsx2/VU1micro.cpp
+++ b/pcsx2/VU1micro.cpp
@@ -32,10 +32,6 @@
 
 VURegs* g_pVU1;
 
-#ifdef PCSX2_VIRTUAL_MEM
-extern PSMEMORYBLOCK s_psVuMem;
-#endif
-
 #ifdef _DEBUG
 u32 vudump = 0;
 #endif
diff --git a/pcsx2/VUmicroMem.cpp b/pcsx2/VUmicroMem.cpp
index b3b9c12f4b..b22cc33791 100644
--- a/pcsx2/VUmicroMem.cpp
+++ b/pcsx2/VUmicroMem.cpp
@@ -26,11 +26,6 @@
 
 #include "iVUzerorec.h"
 
-#ifdef PCSX2_VIRTUAL_MEM
-extern PSMEMORYBLOCK s_psVuMem;
-extern PSMEMORYMAP *memLUT;
-#endif
-
 // The following CpuVU objects are value types instead of handles or pointers because they are
 // modified on the fly to implement VU1 Skip.
 
@@ -87,54 +82,6 @@ static const uint m_vuMemSize =
 
 void vuMicroMemAlloc()
 {
-#ifdef PCSX2_VIRTUAL_MEM
-	jASSUME( memLUT != NULL );		// memAlloc() must always be called first, thanks.
-
-	// unmap all vu0 pages
-	SysMapUserPhysicalPages(PS2MEM_VU0MICRO, 16, NULL, 0);
-
-	// mirror 4 times
-	VU0.Micro = PS2MEM_VU0MICRO;
-
-	// since vuregisters are mapped in vumem0, go to diff addr, but mapping to same physical addr
-    //VirtualFree((void*)0x11000000, 0x10000, MEM_RELEASE); // free just in case
-	bool vu1_reassign = false;
-	if( VU0.Mem == NULL )
-	{
-		VU0.Mem = (u8*)VirtualAlloc((void*)0x11000000, 0x10000, MEM_RESERVE|MEM_PHYSICAL, PAGE_READWRITE);
-		vu1_reassign = true;
-	}
-
-	if( VU0.Mem != (void*)0x11000000 )
-	{
-		VU0.Mem = NULL;
-		throw Exception::OutOfMemory(
-			fmt_string( "Failed to alloc vu0mem 0x11000000 %d", GetLastError() )
-		);
-	}
-
-	memLUT[0x11004].aPFNs = &s_psVuMem.aPFNs[1]; memLUT[0x11004].aVFNs = &s_psVuMem.aVFNs[1];
-	memLUT[0x11005].aPFNs = &s_psVuMem.aPFNs[1]; memLUT[0x11005].aVFNs = &s_psVuMem.aVFNs[1];
-	memLUT[0x11006].aPFNs = &s_psVuMem.aPFNs[1]; memLUT[0x11006].aVFNs = &s_psVuMem.aVFNs[1];
-	memLUT[0x11007].aPFNs = &s_psVuMem.aPFNs[1]; memLUT[0x11007].aVFNs = &s_psVuMem.aVFNs[1];
-
-	// map only registers
-	SysMapUserPhysicalPages(VU0.Mem+0x4000, 1, s_psVuMem.aPFNs, 2);
-
-	if( vu1_reassign )
-	{
-		// Initialize VU1 memory using VU0's allocations:
-		// Important!  VU1 is actually a macro to g_pVU1 (yes, awkward!)  so we need to assign it first.
-		g_pVU1 = (VURegs*)(VU0.Mem + 0x4000);
-
-		VU1.Mem = PS2MEM_VU1MEM;
-		VU1.Micro = PS2MEM_VU1MICRO;
-	}
-
-#else
-
-	// -- VTLB Memory Allocation --
-
 	if( m_vuAllMem == NULL )
 		m_vuAllMem = vtlb_malloc( m_vuMemSize, 16, 0x28000000 );
 
@@ -149,33 +96,15 @@ void vuMicroMemAlloc()
 	VU0.Micro	= curpos; curpos += 0x1000;
 	VU1.Mem		= curpos; curpos += 0x4000;
 	VU1.Micro	= curpos; //curpos += 0x4000;
-
-#endif
 }
 
 void vuMicroMemShutdown()
 {
-#ifdef PCSX2_VIRTUAL_MEM
-
-	if( VU0.Mem != NULL )
-	{
-		if( !SysMapUserPhysicalPages(VU0.Mem, 16, NULL, 0) )
-			Console::Error("Error releasing vu0 memory %d", params GetLastError());
-
-		if( VirtualFree(VU0.Mem, 0, MEM_RELEASE) == 0 )
-			Console::Error("Error freeing vu0 memory %d", params GetLastError());
-	}
-	VU0.Mem = NULL;
-	VU0.Micro = NULL;
-
-#else
-
 	// -- VTLB Memory Allocation --
 
 	vtlb_free( m_vuAllMem, m_vuMemSize );
 	m_vuAllMem = NULL;
 	g_pVU1 = NULL;
-#endif
 }
 
 void vuMicroMemReset()
diff --git a/pcsx2/vtlb.cpp b/pcsx2/vtlb.cpp
index 9749f567b0..bebda82ab4 100644
--- a/pcsx2/vtlb.cpp
+++ b/pcsx2/vtlb.cpp
@@ -33,8 +33,6 @@
 
 #include "PrecompiledHeader.h"
 
-#ifndef PCSX2_VIRTUAL_MEM
-
 #include "Common.h"
 #include "vtlb.h"
 #include "COP0.h"
@@ -591,5 +589,3 @@ void vtlb_free( void* pmem, uint size )
 	safe_aligned_free( pmem );
 #endif
 }
-
-#endif		// PCSX2_VIRTUAL_MEM
diff --git a/pcsx2/vtlb.h b/pcsx2/vtlb.h
index fff55c3de1..551388e4b3 100644
--- a/pcsx2/vtlb.h
+++ b/pcsx2/vtlb.h
@@ -1,10 +1,6 @@
 #ifndef _VTLB_H_
 #define _VTLB_H_
 
-#include <xmmintrin.h>
-
-#ifndef PCSX2_VIRTUAL_MEM
-
 typedef u8 mem8_t;
 typedef u16 mem16_t;
 typedef u32 mem32_t;
@@ -81,5 +77,3 @@ namespace vtlb_private
 }
 
 #endif
-
-#endif
diff --git a/pcsx2/windows/WinMain.cpp b/pcsx2/windows/WinMain.cpp
index 583ba1cc07..cfe468c9bc 100644
--- a/pcsx2/windows/WinMain.cpp
+++ b/pcsx2/windows/WinMain.cpp
@@ -182,10 +182,6 @@ void WinClose()
 
 	SysShutdownDynarecs();
 	SysShutdownMem();
-
-#ifdef PCSX2_VIRTUAL_MEM
-	VirtualFree(PS2MEM_BASE, 0, MEM_RELEASE);
-#endif
 }
 
 BOOL SysLoggedSetLockPagesPrivilege ( HANDLE hProcess, BOOL bEnable);
@@ -308,23 +304,6 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine
 
 	CreateDirectory(LOGS_DIR, NULL);
 
-#ifdef PCSX2_VIRTUAL_MEM
-	LPVOID lpMemReserved;
-
-	if( !SysLoggedSetLockPagesPrivilege( GetCurrentProcess(), TRUE ) )
-		return -1;
-
-	lpMemReserved = VirtualAlloc(PS2MEM_BASE, 0x40000000, MEM_RESERVE, PAGE_NOACCESS);
-
-	if( lpMemReserved == NULL || lpMemReserved!= PS2MEM_BASE ) {
-		char str[255];
-		sprintf(str, "Cannot allocate mem addresses %x-%x, err: %d", PS2MEM_BASE, PS2MEM_BASE+0x40000000, GetLastError());
-		MessageBox(NULL, str, "SysError", MB_OK);
-		return -1;
-	}
-
-#endif
-
 	InitCommonControls();
 	pInstance=hInstance;
 	FirstShow=true;			// this is used by cheats.cpp to search for stuff (broken?)
@@ -1087,11 +1066,7 @@ void CreateMainWindow(int nCmdShow) {
 	GetObject(hbitmap_background, sizeof(bm), &bm);
 
 	{
-#ifdef PCSX2_VIRTUAL_MEM
-		const char* pvm = "VM";
-#else
 		const char* pvm = "VTLB";
-#endif
 
 #ifdef PCSX2_DEVBUILD
 		sprintf(buf, _("PCSX2 %s - %s Compile Date - %s %s"), PCSX2_VERSION, pvm, COMPILEDATE, COMPILER);
diff --git a/pcsx2/windows/cheats/cheats.cpp b/pcsx2/windows/cheats/cheats.cpp
index d6755a37c1..8735119cb4 100644
--- a/pcsx2/windows/cheats/cheats.cpp
+++ b/pcsx2/windows/cheats/cheats.cpp
@@ -69,11 +69,7 @@ char tn[100];
 char to[100];
 char tv[100];
 
-#ifdef PCSX2_VIRTUAL_MEM
-u8 *mptr[2]={PS2MEM_BASE,PS2MEM_PSX};
-#else
 u8 *mptr[2];
-#endif
 
 int  msize[2]={0x02000000,0x00200000};
 
@@ -437,13 +433,10 @@ BOOL CALLBACK FinderProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
 		case WM_PAINT:
 			INIT_CHECK(IDC_UNSIGNED,Unsigned);
 			return FALSE;
-		case WM_INITDIALOG:
 
-#ifndef PCSX2_VIRTUAL_MEM
+		case WM_INITDIALOG:
 			mptr[0]=psM;
 			mptr[1]=psxM;
-#endif
-
 
 			hWndFinder=hWnd;
 
diff --git a/pcsx2/x86/iGS.cpp b/pcsx2/x86/iGS.cpp
index 880f96990b..68639c1b27 100644
--- a/pcsx2/x86/iGS.cpp
+++ b/pcsx2/x86/iGS.cpp
@@ -27,12 +27,8 @@
 #include "GS.h"
 #include "DebugTools/Debug.h"
 	
-#ifdef PCSX2_VIRTUAL_MEM
-#define PS2GS_BASE(mem) ((PS2MEM_BASE+0x12000000)+(mem&0x13ff))
-#else
 extern u8 g_RealGSMem[0x2000];
 #define PS2GS_BASE(mem) (g_RealGSMem+(mem&0x13ff))
-#endif
 
 // __thiscall -- Calling Convention Notes.
 
diff --git a/pcsx2/x86/iHw.cpp b/pcsx2/x86/iHw.cpp
index 559c4e42b1..1ba3a71f12 100644
--- a/pcsx2/x86/iHw.cpp
+++ b/pcsx2/x86/iHw.cpp
@@ -33,10 +33,6 @@
 #include "Sif.h"
 
 
-#ifndef PCSX2_VIRTUAL_MEM
-extern u8  *psH; // hw mem
-#endif
-
 extern int rdram_devices;	// put 8 for TOOL and 2 for PS2 and PSX
 extern int rdram_sdevid;
 extern char sio_buffer[1024];
@@ -192,65 +188,6 @@ int hwConstRead16(u32 x86reg, u32 mem, u32 sign)
 	}
 }
 
-#ifdef PCSX2_VIRTUAL_MEM
-//
-//#if defined(_MSC_VER)
-//__declspec(naked) void recCheckF440()
-//{
-//	__asm {
-//		add b440, 1
-//		mov eax, b440
-//		sub eax, 3
-//		mov edx, 31
-//
-//		cmp eax, 27
-//		ja WriteVal
-//		shl eax, 2
-//		mov edx, dword ptr [eax+b440table]
-//
-//WriteVal:
-//		mov eax, PS2MEM_BASE_+0x1000f440
-//		mov dword ptr [eax], edx
-//		ret
-//	}
-//}
-//#else
-//void recCheckF440();
-//#endif
-
-void iMemRead32Check()
-{
-	// test if 0xf440
-//	if( bExecBIOS ) {
-//		u8* ptempptr[2];
-//		CMP32ItoR(ECX, 0x1000f440);
-//		ptempptr[0] = JNE8(0);
-//
-////		// increment and test
-////		INC32M((uptr)&b440);
-////		MOV32MtoR(EAX, (uptr)&b440);
-////		SUB32ItoR(EAX, 3);
-////		MOV32ItoR(EDX, 31);
-////
-////		CMP32ItoR(EAX, 27);
-////
-////		// look up table
-////		ptempptr[1] = JA8(0);
-////		SHL32ItoR(EAX, 2);
-////		ADD32ItoR(EAX, (int)b440table);
-////		MOV32RmtoR(EDX, EAX);
-////
-////		x86SetJ8( ptempptr[1] );
-////
-////		MOV32RtoM( (int)PS2MEM_HW+0xf440, EDX);
-//		CALLFunc((uptr)recCheckF440);
-//
-//		x86SetJ8( ptempptr[0] );
-//	}
-}
-
-#endif
-
 int hwContRead32_f440()
 {
     if ((psHu32(0xf430) >> 6) & 0xF)
@@ -636,15 +573,7 @@ void hwConstWrite8(u32 mem, int mmreg)
 				case 0x1000f430:
 					break;
 				default:
-#ifdef PCSX2_VIRTUAL_MEM
-					//NOTE: this might cause crashes, but is more correct
-					_eeWriteConstMem8((u32)PS2MEM_BASE + mem, mmreg);
-#else
-					if (mem < 0x10010000)
-					{
-						_eeWriteConstMem8((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
-					}
-#endif
+					_eeWriteConstMem8((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
 			}
 
 			break;
@@ -793,15 +722,7 @@ void hwConstWrite16(u32 mem, int mmreg)
 				return;
 			}
 
-#ifdef PCSX2_VIRTUAL_MEM
-		//NOTE: this might cause crashes, but is more correct
-		_eeWriteConstMem16((u32)PS2MEM_BASE + mem, mmreg);
-#else
-		if (mem < 0x10010000)
-		{
 			_eeWriteConstMem16((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
-		}
-#endif
 	}
 }
 
@@ -1087,15 +1008,7 @@ void hwConstWrite32(u32 mem, int mmreg)
 				return;
 			}
 
-#ifdef PCSX2_VIRTUAL_MEM
-			//NOTE: this might cause crashes, but is more correct
-			_eeWriteConstMem32((u32)PS2MEM_BASE + mem, mmreg);
-#else
-			if (mem < 0x10010000)
-			{
-				_eeWriteConstMem32((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
-			}
-#endif
+			_eeWriteConstMem32((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
 		break;
 	}
 }
@@ -1234,12 +1147,7 @@ void hwConstWrite128(u32 mem, int mmreg)
 
 		default:
 
-#ifdef PCSX2_VIRTUAL_MEM
-			_eeWriteConstMem128( PS2MEM_BASE_+mem, mmreg);
-#else
-			if (mem < 0x10010000)
-				_eeWriteConstMem128((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
-#endif
+			_eeWriteConstMem128((uptr)&PS2MEM_HW[mem&0xffff], mmreg);
 			break;
 	}
 }
diff --git a/pcsx2/x86/ix86-32/iR5900-32.cpp b/pcsx2/x86/ix86-32/iR5900-32.cpp
index 521826b88f..59ce55a411 100644
--- a/pcsx2/x86/ix86-32/iR5900-32.cpp
+++ b/pcsx2/x86/ix86-32/iR5900-32.cpp
@@ -555,10 +555,7 @@ void recResetEE( void )
 	if( s_pInstCache ) memset( s_pInstCache, 0, sizeof(EEINST)*s_nInstCacheSize );
 
 	ResetBaseBlockEx(0);
-
-#ifndef PCSX2_VIRTUAL_MEM
 	mmap_ResetBlockTracking();
-#endif
 
 #ifdef _MSC_VER
 	__asm emms;
@@ -668,19 +665,12 @@ static __naked void Dispatcher()
 	// calc PC_GETBLOCK
 	s_pDispatchBlock = PC_GETBLOCK(cpuRegs.pc);
 	
-	__asm {
-		// check if startpc == cpuRegs.pc
-		mov eax, s_pDispatchBlock
-		mov ecx, cpuRegs.pc
-		cmp ecx, dword ptr [eax+BLOCKTYPE_STARTPC]
-		je CheckPtr
+	if( s_pDispatchBlock == NULL || s_pDispatchBlock->startpc != cpuRegs.pc )
+		recRecompile(cpuRegs.pc);
 
-		// recompile
-		push cpuRegs.pc // pc
-		call recRecompile
-		add esp, 4 // pop old param
+	__asm
+	{
 		mov eax, s_pDispatchBlock
-CheckPtr:
 		mov eax, dword ptr [eax]
 	}
 
@@ -1931,7 +1921,6 @@ StartRecomp:
 	MOV32ItoR(ECX,startpc);
 	MOV32ItoR(EDX,sz);
 
-#ifndef PCSX2_VIRTUAL_MEM
 	while(inpage_sz)
 	{
 		int PageType=mmap_GetRamPageInfo((u32*)PSM(inpage_ptr));
@@ -1968,7 +1957,6 @@ StartRecomp:
 		inpage_sz-=pgsz;
 		inpage_offs=inpage_ptr&0xFFF;
 	}
-#endif
 
 	// finally recompile //
 	g_pCurInstInfo = s_pInstCache;