diff --git a/Source/Project64-core/N64System/Enhancement/Enhancements.cpp b/Source/Project64-core/N64System/Enhancement/Enhancements.cpp
index 88022b03d..88db0bc4f 100644
--- a/Source/Project64-core/N64System/Enhancement/Enhancements.cpp
+++ b/Source/Project64-core/N64System/Enhancement/Enhancements.cpp
@@ -468,29 +468,25 @@ void CEnhancements::ApplyGameSharkCodes(CMipsMemoryVM & MMU, CODES & CodeEntry,
         ModifyMemory16(MMU, 0xA0000000 | (Code.Command() & 0xFFFFFF), Code.Value(), Code.HasDisableValue(), Code.DisableValue());
         break;
     case 0xD0000000:
-        MMU.MemoryValue8(0x80000000 | (Code.Command() & 0xFFFFFF), bMemory);
-        if (bMemory == Code.Value())
+        if (MMU.MemoryValue8(0x80000000 | (Code.Command() & 0xFFFFFF), bMemory) && bMemory == Code.Value())
         {
             ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
         }
         break;
     case 0xD1000000:
-        MMU.MemoryValue16(0x80000000 | (Code.Command() & 0xFFFFFF), wMemory);
-        if (wMemory == Code.Value())
+        if (MMU.MemoryValue16(0x80000000 | (Code.Command() & 0xFFFFFF), wMemory) && wMemory == Code.Value())
         {
             ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
         }
         break;
     case 0xD2000000:
-        MMU.MemoryValue8(0x80000000 | (Code.Command() & 0xFFFFFF), bMemory);
-        if (bMemory != Code.Value())
+        if (MMU.MemoryValue8(0x80000000 | (Code.Command() & 0xFFFFFF), bMemory) && bMemory != Code.Value())
         {
             ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
         }
         break;
     case 0xD3000000:
-        MMU.MemoryValue16(0x80000000 | (Code.Command() & 0xFFFFFF), wMemory);
-        if (wMemory != Code.Value())
+        if (MMU.MemoryValue16(0x80000000 | (Code.Command() & 0xFFFFFF), wMemory) && wMemory != Code.Value())
         {
             ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
         }
@@ -514,16 +510,14 @@ void CEnhancements::ApplyGameSharkCodes(CMipsMemoryVM & MMU, CODES & CodeEntry,
         break;
     case 0xB8000000:
     case 0xBA000000:
-        MMU.MemoryValue8(0x80000000 | (ConvertXP64Address(Code.Command()) & 0xFFFFFF), bMemory);
-        if (bMemory == ConvertXP64Value(Code.Value()))
+        if (MMU.MemoryValue8(0x80000000 | (ConvertXP64Address(Code.Command()) & 0xFFFFFF), bMemory) && bMemory == ConvertXP64Value(Code.Value()))
         {
             ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
         }
         break;
     case 0xB9000000:
     case 0xBB000000:
-        MMU.MemoryValue16(0x80000000 | (ConvertXP64Address(Code.Command()) & 0xFFFFFF), wMemory);
-        if (wMemory == ConvertXP64Value(Code.Value()))
+        if (MMU.MemoryValue16(0x80000000 | (ConvertXP64Address(Code.Command()) & 0xFFFFFF), wMemory) && wMemory == ConvertXP64Value(Code.Value()))
         {
             ApplyGameSharkCodes(MMU, CodeEntry, CurrentEntry + 1);
         }
@@ -585,12 +579,9 @@ void CEnhancements::ModifyMemory8(CMipsMemoryVM & MMU, uint32_t Address, uint8_t
     {
         OriginalValue.Original = DisableValue;
     }
-    else
+    else if (!MMU.MemoryValue8(Address, OriginalValue.Original))
     {
-        if (!MMU.MemoryValue8(Address, OriginalValue.Original))
-        {
-            return;
-        }
+        return;
     }
     if (OriginalValue.Original == Value)
     {
@@ -612,12 +603,9 @@ void CEnhancements::ModifyMemory16(CMipsMemoryVM & MMU, uint32_t Address, uint16
     {
         OriginalValue.Original = DisableValue;
     }
-    else
+    else if (!MMU.MemoryValue16(Address, OriginalValue.Original))
     {
-        if (!MMU.MemoryValue16(Address, OriginalValue.Original))
-        {
-            return;
-        }
+        return;
     }
     if (OriginalValue.Original == Value)
     {
diff --git a/Source/Project64-core/N64System/Mips/MemoryVirtualMem.cpp b/Source/Project64-core/N64System/Mips/MemoryVirtualMem.cpp
index 8ffb157ec..87f269ecc 100755
--- a/Source/Project64-core/N64System/Mips/MemoryVirtualMem.cpp
+++ b/Source/Project64-core/N64System/Mips/MemoryVirtualMem.cpp
@@ -267,178 +267,100 @@ void CMipsMemoryVM::FreeMemory()
     CPifRam::Reset();
 }
 
-bool CMipsMemoryVM::MemoryValue8(uint32_t VAddr, uint8_t& Value)
+uint8_t * CMipsMemoryVM::MemoryPtr(uint32_t VAddr, uint32_t size, bool Read)
 {
     if (m_TLB_ReadMap[VAddr >> 12] == -1)
     {
-        return false;
+        return nullptr;
     }
-    uint32_t PAddr = (m_TLB_ReadMap[VAddr >> 12] + VAddr) ^ 3;
-    if (PAddr < m_AllocatedRdramSize)
+    uint32_t PAddr = m_TLB_ReadMap[VAddr >> 12] + VAddr;
+    if ((PAddr + size) < m_AllocatedRdramSize)
     {
-        Value = *(uint8_t*)(m_RDRAM + PAddr);
-        return true;
+        return (uint8_t*)(m_RDRAM + PAddr);
     }
 
-    if (PAddr >= 0x04000000 && PAddr < 0x04001000)
+    if (PAddr >= 0x04000000 && (PAddr + size) < 0x04001000)
     {
-        Value = *(uint8_t*)(m_DMEM + (PAddr - 0x04000000));
-        return true;
+        return (uint8_t*)(m_DMEM + (PAddr - 0x04000000));
     }
-    if (PAddr >= 0x04001000 && PAddr < 0x04002000)
+    if (PAddr >= 0x04001000 && (PAddr + size) < 0x04002000)
     {
-        Value = *(uint8_t*)(m_IMEM + (PAddr - 0x04001000));
-        return true;
+        return (uint8_t*)(m_IMEM + (PAddr - 0x04001000));
     }
+    if (Read && PAddr >= 0x10000000 && (PAddr + size) < (0x10000000 + m_Rom.GetRomSize()))
+    {
+        return (uint8_t *)&m_Rom.GetRomAddress()[PAddr - 0x10000000];
+    }
+
     g_Notify->BreakPoint(__FILE__, __LINE__);
-    return false;
+    return nullptr;
+
+}
+
+bool CMipsMemoryVM::MemoryValue8(uint32_t VAddr, uint8_t & Value)
+{
+    uint8_t * ptr = MemoryPtr(VAddr ^ 3, 1, true);
+    if (ptr == nullptr)
+    {
+        return false;
+    }
+    Value = *ptr;
+    return true;
 }
 
 bool CMipsMemoryVM::MemoryValue16(uint32_t VAddr, uint16_t& Value)
 {
-    if (m_TLB_ReadMap[VAddr >> 12] == -1)
+    uint8_t * ptr = MemoryPtr(VAddr ^ 2, 2, true);
+    if (ptr == nullptr)
     {
         return false;
     }
-    uint32_t PAddr = (m_TLB_ReadMap[VAddr >> 12] + VAddr) ^ 2;
-    if (PAddr < m_AllocatedRdramSize)
-    {
-        Value = *(uint16_t*)(m_RDRAM + PAddr);
-        return true;
-    }
-
-    if (PAddr >= 0x04000000 && PAddr < 0x04001000)
-    {
-        Value = *(uint16_t*)(m_DMEM + (PAddr - 0x04000000));
-        return true;
-    }
-    if (PAddr >= 0x04001000 && PAddr < 0x04002000)
-    {
-        Value = *(uint16_t*)(m_IMEM + (PAddr - 0x04001000));
-        return true;
-    }
-    g_Notify->BreakPoint(__FILE__, __LINE__);
-    return false;
+    Value = *(uint16_t*)(ptr);
+    return true;
 }
 
 bool CMipsMemoryVM::MemoryValue32(uint32_t VAddr, uint32_t& Value)
 {
-    if (m_TLB_ReadMap[VAddr >> 12] == -1)
+    uint8_t * ptr = MemoryPtr(VAddr, 4, true);
+    if (ptr == nullptr)
     {
         return false;
     }
-    uint32_t PAddr = m_TLB_ReadMap[VAddr >> 12] + VAddr;
-    if (PAddr < m_AllocatedRdramSize)
-    {
-        Value = *(uint32_t*)(m_RDRAM + PAddr);
-        return true;
-    }
-
-    if (PAddr >= 0x04000000 && PAddr < 0x04001000)
-    {
-        Value = *(uint32_t*)(m_DMEM + (PAddr - 0x04000000));
-        return true;
-    }
-    if (PAddr >= 0x04001000 && PAddr < 0x04002000)
-    {
-        Value = *(uint32_t*)(m_IMEM + (PAddr - 0x04001000));
-        return true;
-    }
-    if (PAddr >= 0x10000000 && PAddr < 0x16000000)
-    {
-        if ((PAddr & 0xFFFFFFF) < m_Rom.GetRomSize())
-        {
-            Value = *(uint32_t *)&m_Rom.GetRomAddress()[(PAddr & 0xFFFFFFF)];
-        }
-        else
-        {
-            Value = (PAddr << 16) | (PAddr & 0xFFFF);
-        }
-        return true;
-    }
-    g_Notify->BreakPoint(__FILE__, __LINE__);
-    return false;
+    Value = *(uint32_t*)(ptr);
+    return true;
 }
 
 bool CMipsMemoryVM::UpdateMemoryValue8(uint32_t VAddr, uint8_t Value)
 {
-    if (m_TLB_ReadMap[VAddr >> 12] == -1)
+    uint8_t * ptr = MemoryPtr(VAddr ^ 3, 1, false);
+    if (ptr == nullptr)
     {
         return false;
     }
-    uint32_t PAddr = (m_TLB_ReadMap[VAddr >> 12] + VAddr) ^ 3;
-    if (PAddr < m_AllocatedRdramSize)
-    {
-        *(uint8_t*)(m_RDRAM + PAddr) = Value;
-        return true;
-    }
-
-    if (PAddr >= 0x04000000 && PAddr < 0x04001000)
-    {
-        *(uint8_t*)(m_DMEM + (PAddr - 0x04000000)) = Value;
-        return true;
-    }
-    if (PAddr >= 0x04001000 && PAddr < 0x04002000)
-    {
-        *(uint8_t*)(m_IMEM + (PAddr - 0x04001000)) = Value;
-        return true;
-    }
-    g_Notify->BreakPoint(__FILE__, __LINE__);
-    return false;
+    *ptr = Value;
+    return true;
 }
 
 bool CMipsMemoryVM::UpdateMemoryValue16(uint32_t VAddr, uint16_t Value)
 {
-    if (m_TLB_ReadMap[VAddr >> 12] == -1)
+    uint8_t * ptr = MemoryPtr(VAddr ^ 2, 2, false);
+    if (ptr == nullptr)
     {
         return false;
     }
-    uint32_t PAddr = (m_TLB_ReadMap[VAddr >> 12] + VAddr) ^ 2;
-    if (PAddr < m_AllocatedRdramSize)
-    {
-        *(uint16_t*)(m_RDRAM + PAddr) = Value;
-        return true;
-    }
-
-    if (PAddr >= 0x04000000 && PAddr < 0x04001000)
-    {
-        *(uint16_t*)(m_DMEM + (PAddr - 0x04000000)) = Value;
-        return true;
-    }
-    if (PAddr >= 0x04001000 && PAddr < 0x04002000)
-    {
-        *(uint16_t*)(m_IMEM + (PAddr - 0x04001000)) = Value;
-        return true;
-    }
-    g_Notify->BreakPoint(__FILE__, __LINE__);
-    return false;
+    *(uint16_t*)(ptr) = Value;
+    return true;
 }
 
 bool CMipsMemoryVM::UpdateMemoryValue32(uint32_t VAddr, uint32_t Value)
 {
-    if (m_TLB_ReadMap[VAddr >> 12] == -1)
+    uint8_t * ptr = MemoryPtr(VAddr, 4, false);
+    if (ptr == nullptr)
     {
         return false;
     }
-    uint32_t PAddr = m_TLB_ReadMap[VAddr >> 12] + VAddr;
-    if (PAddr < m_AllocatedRdramSize)
-    {
-        *(uint32_t*)(m_RDRAM + PAddr) = Value;
-        return true;
-    }
-
-    if (PAddr >= 0x04000000 && PAddr < 0x04001000)
-    {
-        *(uint32_t*)(m_DMEM + (PAddr - 0x04000000)) = Value;
-        return true;
-    }
-    if (PAddr >= 0x04001000 && PAddr < 0x04002000)
-    {
-        *(uint32_t*)(m_IMEM + (PAddr - 0x04001000)) = Value;
-        return true;
-    }
-    g_Notify->BreakPoint(__FILE__, __LINE__);
-    return false;
+    *(uint32_t*)(ptr) = Value;
+    return true;
 }
 
 bool CMipsMemoryVM::LB_Memory(uint32_t VAddr, uint8_t& Value)
@@ -822,7 +744,7 @@ bool CMipsMemoryVM::SW_NonMemory(uint32_t VAddr, uint32_t Value)
     return true;
 }
 
-bool CMipsMemoryVM::SD_NonMemory(uint32_t VAddr, uint64_t Value)
+bool CMipsMemoryVM::SD_NonMemory(uint32_t VAddr, uint64_t /*Value*/)
 {
     uint32_t BaseAddress = m_TLB_ReadMap[VAddr >> 12];
     if (BaseAddress == -1)
diff --git a/Source/Project64-core/N64System/Mips/MemoryVirtualMem.h b/Source/Project64-core/N64System/Mips/MemoryVirtualMem.h
index 538192c19..e6659dd5a 100644
--- a/Source/Project64-core/N64System/Mips/MemoryVirtualMem.h
+++ b/Source/Project64-core/N64System/Mips/MemoryVirtualMem.h
@@ -73,6 +73,8 @@ public:
     CSram & GetSram() { return m_CartridgeDomain2Address2Handler.Sram(); }
     CFlashRam & GetFlashRam() { return m_CartridgeDomain2Address2Handler.FlashRam(); }
 
+    uint8_t * MemoryPtr(uint32_t VAddr, uint32_t size, bool Read);
+
     bool MemoryValue8(uint32_t VAddr, uint8_t & Value);
     bool MemoryValue16(uint32_t VAddr, uint16_t & Value);
     bool MemoryValue32(uint32_t VAddr, uint32_t & Value);
diff --git a/Source/Project64-core/N64System/Recompiler/CodeBlock.cpp b/Source/Project64-core/N64System/Recompiler/CodeBlock.cpp
index 9d0c5da38..bd2ded06a 100644
--- a/Source/Project64-core/N64System/Recompiler/CodeBlock.cpp
+++ b/Source/Project64-core/N64System/Recompiler/CodeBlock.cpp
@@ -66,26 +66,17 @@ CCodeBlock::CCodeBlock(CMipsMemoryVM & MMU, uint32_t VAddrEnter, uint8_t * Compi
     m_SectionMap.insert(SectionMap::value_type(VAddrEnter, m_EnterSection));
 
     uint32_t PAddr;
-    if (!MMU.VAddrToPAddr(VAddrEnter, PAddr))
+    memset(m_MemLocation, 0, sizeof(m_MemLocation));
+    memset(m_MemContents, 0, sizeof(m_MemContents));
+
+    m_MemLocation[0] = (uint64_t *)MMU.MemoryPtr(VAddrEnter, 16, true);
+    if (m_MemLocation[0] != 0)
     {
-        memset(m_MemLocation, 0, sizeof(m_MemLocation));
-        memset(m_MemContents, 0, sizeof(m_MemContents));
-        return;
-    }
-    if (PAddr + 16 < MMU.RdramSize())
-    {
-        m_MemLocation[0] = (uint64_t *)(MMU.Rdram() + PAddr);
         m_MemLocation[1] = m_MemLocation[0] + 1;
         m_MemContents[0] = *m_MemLocation[0];
         m_MemContents[1] = *m_MemLocation[1];
+        AnalyseBlock();
     }
-    else
-    {
-        memset(m_MemLocation, 0, sizeof(m_MemLocation));
-        memset(m_MemContents, 0, sizeof(m_MemContents));
-        return;
-    }
-    AnalyseBlock();
 }
 
 CCodeBlock::~CCodeBlock()