diff --git a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp
index f4ac70e2..a13a0077 100644
--- a/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp
+++ b/src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp
@@ -369,7 +369,8 @@ namespace
             {
                 if (reusable)
                 {
-                    LINEF("if (*{0} == PTR_FOLLOWING)", MakeTypePtrVarName(def))
+                    LINEF("const auto zonePtrType = GetZonePointerType(*{0});", MakeTypePtrVarName(def))
+                    LINEF("if (zonePtrType == ZonePointerType::FOLLOWING)", MakeTypePtrVarName(def))
                     LINE("{")
                     m_intendation++;
 
@@ -805,7 +806,7 @@ namespace
             {
                 LINE("")
                 LINEF("{0}** toInsert = nullptr;", member->m_member->m_type_declaration->m_type->GetFullName())
-                LINE("if (ptr == PTR_INSERT)")
+                LINE("if (zonePtrType == ZonePointerType::INSERT)")
                 m_intendation++;
                 LINEF("toInsert = m_stream.InsertPointerNative<{0}>();", member->m_member->m_type_declaration->m_type->GetFullName())
                 m_intendation--;
@@ -850,10 +851,12 @@ namespace
                 return;
             }
 
+            LINEF("const auto zonePtrType = GetZonePointerType({0});", MakeMemberAccess(info, member, modifier))
+
             const MemberComputations computations(member);
             if (computations.IsInTempBlock())
             {
-                LINEF("if ({0} == PTR_FOLLOWING || {0} == PTR_INSERT)", MakeMemberAccess(info, member, modifier))
+                LINE("if (zonePtrType == ZonePointerType::FOLLOWING || zonePtrType == ZonePointerType::INSERT)")
                 LINE("{")
                 m_intendation++;
 
@@ -872,7 +875,7 @@ namespace
             }
             else
             {
-                LINEF("if ({0} == PTR_FOLLOWING)", MakeMemberAccess(info, member, modifier))
+                LINE("if (zonePtrType == ZonePointerType::FOLLOWING)")
                 LINE("{")
                 m_intendation++;
 
@@ -1213,13 +1216,14 @@ namespace
             LINE("{")
             m_intendation++;
 
+            LINEF("const auto zonePtrType = GetZonePointerType(*{0});", MakeTypePtrVarName(info->m_definition))
             if (inTemp)
             {
-                LINEF("if (*{0} == PTR_FOLLOWING || *{0} == PTR_INSERT)", MakeTypePtrVarName(info->m_definition))
+                LINEF("if (zonePtrType == ZonePointerType::FOLLOWING || zonePtrType == ZonePointerType::INSERT)", MakeTypePtrVarName(info->m_definition))
             }
             else
             {
-                LINEF("if (*{0} == PTR_FOLLOWING)", MakeTypePtrVarName(info->m_definition))
+                LINEF("if (zonePtrType == ZonePointerType::FOLLOWING)", MakeTypePtrVarName(info->m_definition))
             }
             LINE("{")
             m_intendation++;
@@ -1237,7 +1241,7 @@ namespace
             {
                 LINE("")
                 LINEF("{0}** toInsert = nullptr;", info->m_definition->GetFullName())
-                LINE("if (ptr == PTR_INSERT)")
+                LINE("if (zonePtrType == ZonePointerType::INSERT)")
                 m_intendation++;
                 LINEF("toInsert = m_stream.InsertPointerNative<{0}>();", info->m_definition->GetFullName())
                 m_intendation--;
diff --git a/src/ZoneCommon/Zone/XBlock.cpp b/src/ZoneCommon/Zone/XBlock.cpp
index f5825865..239ab536 100644
--- a/src/ZoneCommon/Zone/XBlock.cpp
+++ b/src/ZoneCommon/Zone/XBlock.cpp
@@ -1,34 +1,23 @@
 #include "XBlock.h"
 
-#include <cassert>
-
-XBlock::XBlock(const std::string& name, const int index, const Type type)
+XBlock::XBlock(std::string name, const unsigned index, const XBlockType type)
+    : m_name(std::move(name)),
+      m_index(index),
+      m_type(type),
+      m_buffer_size(0u)
 {
-    m_name = name;
-    m_index = index;
-    m_type = type;
-    m_buffer = nullptr;
-    m_buffer_size = 0;
-}
-
-XBlock::~XBlock()
-{
-    delete[] m_buffer;
-    m_buffer = nullptr;
 }
 
 void XBlock::Alloc(const size_t blockSize)
 {
-    delete[] m_buffer;
-
     if (blockSize > 0)
     {
-        m_buffer = new uint8_t[blockSize];
+        m_buffer = std::make_unique<uint8_t[]>(blockSize);
         m_buffer_size = blockSize;
     }
     else
     {
-        m_buffer = nullptr;
+        m_buffer.reset();
         m_buffer_size = 0;
     }
 }
diff --git a/src/ZoneCommon/Zone/XBlock.h b/src/ZoneCommon/Zone/XBlock.h
index 8128864a..a1cb17c4 100644
--- a/src/ZoneCommon/Zone/XBlock.h
+++ b/src/ZoneCommon/Zone/XBlock.h
@@ -1,27 +1,29 @@
 #pragma once
+
+#include <cstddef>
 #include <cstdint>
+#include <memory>
 #include <string>
 
+enum class XBlockType : std::uint8_t
+{
+    BLOCK_TYPE_TEMP,
+    BLOCK_TYPE_RUNTIME,
+    BLOCK_TYPE_DELAY,
+    BLOCK_TYPE_NORMAL
+};
+
 class XBlock
 {
 public:
-    enum class Type
-    {
-        BLOCK_TYPE_TEMP,
-        BLOCK_TYPE_RUNTIME,
-        BLOCK_TYPE_DELAY,
-        BLOCK_TYPE_NORMAL
-    };
+    XBlock(std::string name, unsigned index, XBlockType type);
+
+    void Alloc(size_t blockSize);
 
     std::string m_name;
     unsigned m_index;
-    Type m_type;
+    XBlockType m_type;
 
-    uint8_t* m_buffer;
+    std::unique_ptr<uint8_t[]> m_buffer;
     size_t m_buffer_size;
-
-    XBlock(const std::string& name, int index, Type type);
-    ~XBlock();
-
-    void Alloc(size_t blockSize);
 };
diff --git a/src/ZoneLoading/Game/IW3/ContentLoaderIW3.cpp b/src/ZoneLoading/Game/IW3/ContentLoaderIW3.cpp
index 8ad2b90a..02f9c444 100644
--- a/src/ZoneLoading/Game/IW3/ContentLoaderIW3.cpp
+++ b/src/ZoneLoading/Game/IW3/ContentLoaderIW3.cpp
@@ -48,7 +48,7 @@ void ContentLoader::LoadScriptStringList(const bool atStreamStart)
 
     if (varScriptStringList->strings != nullptr)
     {
-        assert(varScriptStringList->strings == PTR_FOLLOWING);
+        assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING);
 
         varScriptStringList->strings = m_stream.Alloc<const char*>(alignof(const char*));
         varXString = varScriptStringList->strings;
@@ -146,7 +146,7 @@ void ContentLoader::Load()
 
     if (assetList.assets != nullptr)
     {
-        assert(assetList.assets == PTR_FOLLOWING);
+        assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING);
 
         assetList.assets = m_stream.Alloc<XAsset>(alignof(XAsset));
         varXAsset = assetList.assets;
diff --git a/src/ZoneLoading/Game/IW3/ZoneLoaderFactoryIW3.cpp b/src/ZoneLoading/Game/IW3/ZoneLoaderFactoryIW3.cpp
index 557b976d..553fe88c 100644
--- a/src/ZoneLoading/Game/IW3/ZoneLoaderFactoryIW3.cpp
+++ b/src/ZoneLoading/Game/IW3/ZoneLoaderFactoryIW3.cpp
@@ -44,15 +44,15 @@ namespace
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -92,7 +92,8 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader&
         },
         32u,
         ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
-        ZoneConstants::INSERT_BLOCK));
+        ZoneConstants::INSERT_BLOCK,
+        zonePtr->Memory()));
 
     return zoneLoader;
 }
diff --git a/src/ZoneLoading/Game/IW4/ContentLoaderIW4.cpp b/src/ZoneLoading/Game/IW4/ContentLoaderIW4.cpp
index 62782ed7..a49083ed 100644
--- a/src/ZoneLoading/Game/IW4/ContentLoaderIW4.cpp
+++ b/src/ZoneLoading/Game/IW4/ContentLoaderIW4.cpp
@@ -71,9 +71,9 @@ void ContentLoader::LoadScriptStringList(const bool atStreamStart)
 
     if (varScriptStringList->strings != nullptr)
     {
-        assert(varScriptStringList->strings == PTR_FOLLOWING);
+        assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING);
 
-        varScriptStringList->strings = m_stream.Alloc<const char*>(4);
+        varScriptStringList->strings = m_stream.AllocOutOfBlock<const char*>(4, varScriptStringList->count);
         varXString = varScriptStringList->strings;
         LoadXStringArray(true, varScriptStringList->count);
 
@@ -179,7 +179,7 @@ void ContentLoader::Load()
 
     if (assetList.assets != nullptr)
     {
-        assert(assetList.assets == PTR_FOLLOWING);
+        assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING);
 
         assetList.assets = m_stream.Alloc<XAsset>(alignof(XAsset));
         varXAsset = assetList.assets;
diff --git a/src/ZoneLoading/Game/IW4/ZoneLoaderFactoryIW4.cpp b/src/ZoneLoading/Game/IW4/ZoneLoaderFactoryIW4.cpp
index 7e13c582..bfb5dd4f 100644
--- a/src/ZoneLoading/Game/IW4/ZoneLoaderFactoryIW4.cpp
+++ b/src/ZoneLoading/Game/IW4/ZoneLoaderFactoryIW4.cpp
@@ -80,14 +80,14 @@ namespace
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_CALLBACK, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(IW4::XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -214,7 +214,8 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader&
         },
         32u,
         ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
-        ZoneConstants::INSERT_BLOCK));
+        ZoneConstants::INSERT_BLOCK,
+        zonePtr->Memory()));
 
     return zoneLoader;
 }
diff --git a/src/ZoneLoading/Game/IW5/ContentLoaderIW5.cpp b/src/ZoneLoading/Game/IW5/ContentLoaderIW5.cpp
index b8430c67..c524d3b1 100644
--- a/src/ZoneLoading/Game/IW5/ContentLoaderIW5.cpp
+++ b/src/ZoneLoading/Game/IW5/ContentLoaderIW5.cpp
@@ -63,7 +63,7 @@ void ContentLoader::LoadScriptStringList(const bool atStreamStart)
 
     if (varScriptStringList->strings != nullptr)
     {
-        assert(varScriptStringList->strings == PTR_FOLLOWING);
+        assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING);
 
         varScriptStringList->strings = m_stream.Alloc<const char*>(alignof(const char*));
         varXString = varScriptStringList->strings;
@@ -175,7 +175,7 @@ void ContentLoader::Load()
 
     if (assetList.assets != nullptr)
     {
-        assert(assetList.assets == PTR_FOLLOWING);
+        assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING);
 
         assetList.assets = m_stream.Alloc<XAsset>(alignof(XAsset));
         varXAsset = assetList.assets;
diff --git a/src/ZoneLoading/Game/IW5/ZoneLoaderFactoryIW5.cpp b/src/ZoneLoading/Game/IW5/ZoneLoaderFactoryIW5.cpp
index eeb68206..162fc445 100644
--- a/src/ZoneLoading/Game/IW5/ZoneLoaderFactoryIW5.cpp
+++ b/src/ZoneLoading/Game/IW5/ZoneLoaderFactoryIW5.cpp
@@ -63,15 +63,15 @@ namespace
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_SCRIPT, XBlock::Type::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_SCRIPT, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -191,7 +191,8 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader&
         },
         32u,
         ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
-        ZoneConstants::INSERT_BLOCK));
+        ZoneConstants::INSERT_BLOCK,
+        zonePtr->Memory()));
 
     return zoneLoader;
 }
diff --git a/src/ZoneLoading/Game/T5/ContentLoaderT5.cpp b/src/ZoneLoading/Game/T5/ContentLoaderT5.cpp
index b26734bb..9536f02a 100644
--- a/src/ZoneLoading/Game/T5/ContentLoaderT5.cpp
+++ b/src/ZoneLoading/Game/T5/ContentLoaderT5.cpp
@@ -55,7 +55,7 @@ void ContentLoader::LoadScriptStringList(const bool atStreamStart)
 
     if (varScriptStringList->strings != nullptr)
     {
-        assert(varScriptStringList->strings == PTR_FOLLOWING);
+        assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING);
 
         varScriptStringList->strings = m_stream.Alloc<const char*>(alignof(const char*));
         varXString = varScriptStringList->strings;
@@ -159,7 +159,7 @@ void ContentLoader::Load()
 
     if (assetList.assets != nullptr)
     {
-        assert(assetList.assets == PTR_FOLLOWING);
+        assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING);
 
         assetList.assets = m_stream.Alloc<XAsset>(alignof(XAsset));
         varXAsset = assetList.assets;
diff --git a/src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.cpp b/src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.cpp
index 555d955f..23331452 100644
--- a/src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.cpp
+++ b/src/ZoneLoading/Game/T5/ZoneLoaderFactoryT5.cpp
@@ -46,13 +46,13 @@ namespace
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -92,7 +92,8 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader&
         },
         32u,
         ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
-        ZoneConstants::INSERT_BLOCK));
+        ZoneConstants::INSERT_BLOCK,
+        zonePtr->Memory()));
 
     return zoneLoader;
 }
diff --git a/src/ZoneLoading/Game/T6/ContentLoaderT6.cpp b/src/ZoneLoading/Game/T6/ContentLoaderT6.cpp
index 12c62d4f..b551cd91 100644
--- a/src/ZoneLoading/Game/T6/ContentLoaderT6.cpp
+++ b/src/ZoneLoading/Game/T6/ContentLoaderT6.cpp
@@ -71,7 +71,7 @@ void ContentLoader::LoadScriptStringList(const bool atStreamStart)
 
     if (varScriptStringList->strings != nullptr)
     {
-        assert(varScriptStringList->strings == PTR_FOLLOWING);
+        assert(GetZonePointerType(varScriptStringList->strings) == ZonePointerType::FOLLOWING);
 
         varScriptStringList->strings = m_stream.Alloc<const char*>(alignof(const char*));
         varXString = varScriptStringList->strings;
@@ -188,7 +188,7 @@ void ContentLoader::Load()
 
     if (assetList.depends != nullptr)
     {
-        assert(assetList.depends == PTR_FOLLOWING);
+        assert(GetZonePointerType(assetList.depends) == ZonePointerType::FOLLOWING);
 
         assetList.depends = m_stream.Alloc<const char*>(alignof(const char*));
         varXString = assetList.depends;
@@ -197,7 +197,7 @@ void ContentLoader::Load()
 
     if (assetList.assets != nullptr)
     {
-        assert(assetList.assets == PTR_FOLLOWING);
+        assert(GetZonePointerType(assetList.assets) == ZonePointerType::FOLLOWING);
 
         assetList.assets = m_stream.Alloc<XAsset>(alignof(XAsset));
         varXAsset = assetList.assets;
diff --git a/src/ZoneLoading/Game/T6/ZoneLoaderFactoryT6.cpp b/src/ZoneLoading/Game/T6/ZoneLoaderFactoryT6.cpp
index 4df11d30..cdc06d5d 100644
--- a/src/ZoneLoading/Game/T6/ZoneLoaderFactoryT6.cpp
+++ b/src/ZoneLoading/Game/T6/ZoneLoaderFactoryT6.cpp
@@ -93,14 +93,14 @@ namespace
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_VIRTUAL, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_PHYSICAL, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_VIRTUAL, XBlock::Type::BLOCK_TYPE_DELAY));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_PHYSICAL, XBlock::Type::BLOCK_TYPE_DELAY));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_STREAMER_RESERVE, XBlock::Type::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_VIRTUAL, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_PHYSICAL, XBlockType::BLOCK_TYPE_RUNTIME));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_VIRTUAL, XBlockType::BLOCK_TYPE_DELAY));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_PHYSICAL, XBlockType::BLOCK_TYPE_DELAY));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        zoneLoader.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_STREAMER_RESERVE, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
@@ -210,7 +210,8 @@ std::unique_ptr<ZoneLoader> ZoneLoaderFactory::CreateLoaderForHeader(ZoneHeader&
         },
         32u,
         ZoneConstants::OFFSET_BLOCK_BIT_COUNT,
-        ZoneConstants::INSERT_BLOCK));
+        ZoneConstants::INSERT_BLOCK,
+        zonePtr->Memory()));
 
     if (isSecure)
     {
diff --git a/src/ZoneLoading/Loading/ContentLoaderBase.cpp b/src/ZoneLoading/Loading/ContentLoaderBase.cpp
index 45fa3b1a..ae92935a 100644
--- a/src/ZoneLoading/Loading/ContentLoaderBase.cpp
+++ b/src/ZoneLoading/Loading/ContentLoaderBase.cpp
@@ -1,15 +1,22 @@
 #include "ContentLoaderBase.h"
 
 #include <cassert>
-
-const void* ContentLoaderBase::PTR_FOLLOWING = reinterpret_cast<void*>(-1);
-const void* ContentLoaderBase::PTR_INSERT = reinterpret_cast<void*>(-2);
+#include <cstdint>
+#include <limits>
 
 ContentLoaderBase::ContentLoaderBase(Zone& zone, ZoneInputStream& stream)
     : varXString(nullptr),
       m_zone(zone),
       m_memory(zone.Memory()),
-      m_stream(stream)
+      m_stream(stream),
+
+      // -1
+      m_zone_ptr_following(
+          reinterpret_cast<const void*>(std::numeric_limits<std::uintptr_t>::max() >> ((sizeof(std::uintptr_t) * 8u) - stream.GetPointerBitCount()))),
+
+      // -2
+      m_zone_ptr_insert(
+          reinterpret_cast<const void*>((std::numeric_limits<std::uintptr_t>::max() >> ((sizeof(std::uintptr_t) * 8u) - stream.GetPointerBitCount())) - 1u))
 {
 }
 
@@ -22,9 +29,9 @@ void ContentLoaderBase::LoadXString(const bool atStreamStart) const
 
     if (*varXString != nullptr)
     {
-        if (*varXString == PTR_FOLLOWING)
+        if (GetZonePointerType(varXString) == ZonePointerType::FOLLOWING)
         {
-            *varXString = m_stream.Alloc<const char>(alignof(const char));
+            *varXString = m_stream.Alloc<const char>(1);
             m_stream.LoadNullTerminated(const_cast<char*>(*varXString));
         }
         else
@@ -39,7 +46,10 @@ void ContentLoaderBase::LoadXStringArray(const bool atStreamStart, const size_t
     assert(varXString != nullptr);
 
     if (atStreamStart)
+    {
+        m_stream.LoadWithFill(4u * count);
         m_stream.Load<const char*>(varXString, count);
+    }
 
     for (size_t index = 0; index < count; index++)
     {
@@ -47,3 +57,13 @@ void ContentLoaderBase::LoadXStringArray(const bool atStreamStart, const size_t
         varXString++;
     }
 }
+
+ZonePointerType ContentLoaderBase::GetZonePointerType(const void* zonePtr) const
+{
+    if (zonePtr == m_zone_ptr_following)
+        return ZonePointerType::FOLLOWING;
+    if (zonePtr == m_zone_ptr_insert)
+        return ZonePointerType::INSERT;
+
+    return ZonePointerType::OFFSET;
+}
diff --git a/src/ZoneLoading/Loading/ContentLoaderBase.h b/src/ZoneLoading/Loading/ContentLoaderBase.h
index 5edddb5e..8093476d 100644
--- a/src/ZoneLoading/Loading/ContentLoaderBase.h
+++ b/src/ZoneLoading/Loading/ContentLoaderBase.h
@@ -3,12 +3,17 @@
 #include "Zone/Stream/ZoneInputStream.h"
 #include "Zone/Zone.h"
 
+#include <cstdint>
+
+enum class ZonePointerType : std::uint8_t
+{
+    FOLLOWING,
+    INSERT,
+    OFFSET
+};
+
 class ContentLoaderBase
 {
-protected:
-    static const void* PTR_FOLLOWING;
-    static const void* PTR_INSERT;
-
 public:
     virtual ~ContentLoaderBase() = default;
     ContentLoaderBase(const ContentLoaderBase& other) = default;
@@ -22,9 +27,20 @@ protected:
     void LoadXString(bool atStreamStart) const;
     void LoadXStringArray(bool atStreamStart, size_t count);
 
+    [[nodiscard]] ZonePointerType GetZonePointerType(const void* zonePtr) const;
+
+    template<typename T> [[nodiscard]] ZonePointerType GetZonePointerType(T* zonePtr) const
+    {
+        return GetZonePointerType(reinterpret_cast<const void*>(zonePtr));
+    }
+
     const char** varXString;
 
     Zone& m_zone;
     MemoryManager& m_memory;
     ZoneInputStream& m_stream;
+
+private:
+    const void* m_zone_ptr_following;
+    const void* m_zone_ptr_insert;
 };
diff --git a/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp b/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp
index c4b9d59e..7e75ceca 100644
--- a/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepAllocXBlocks.cpp
@@ -4,7 +4,7 @@
 
 namespace
 {
-    constexpr uint64_t MAX_XBLOCK_SIZE = 0x3C000000;
+    constexpr uint64_t MAX_XBLOCK_SIZE = 0x3C000000; // ~1GB
 
     class StepAllocXBlocks final : public ILoadingStep
     {
diff --git a/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp b/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp
index 651b36f6..80cb3591 100644
--- a/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp
+++ b/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.cpp
@@ -10,17 +10,20 @@ namespace
         StepLoadZoneContent(std::function<std::unique_ptr<IContentLoadingEntryPoint>(ZoneInputStream&)> entryPointFactory,
                             const unsigned pointerBitCount,
                             const unsigned offsetBlockBitCount,
-                            const block_t insertBlock)
+                            const block_t insertBlock,
+                            MemoryManager& memory)
             : m_entry_point_factory(std::move(entryPointFactory)),
               m_pointer_bit_count(pointerBitCount),
               m_offset_block_bit_count(offsetBlockBitCount),
-              m_insert_block(insertBlock)
+              m_insert_block(insertBlock),
+              m_memory(memory)
         {
         }
 
         void PerformStep(ZoneLoader& zoneLoader, ILoadingStream& stream) override
         {
-            const auto inputStream = ZoneInputStream::Create(m_pointer_bit_count, m_offset_block_bit_count, zoneLoader.m_blocks, m_insert_block, stream);
+            const auto inputStream =
+                ZoneInputStream::Create(m_pointer_bit_count, m_offset_block_bit_count, zoneLoader.m_blocks, m_insert_block, stream, m_memory);
 
             const auto entryPoint = m_entry_point_factory(*inputStream);
             assert(entryPoint);
@@ -33,6 +36,7 @@ namespace
         unsigned m_pointer_bit_count;
         unsigned m_offset_block_bit_count;
         block_t m_insert_block;
+        MemoryManager& m_memory;
     };
 } // namespace
 
@@ -41,8 +45,9 @@ namespace step
     std::unique_ptr<ILoadingStep> CreateStepLoadZoneContent(std::function<std::unique_ptr<IContentLoadingEntryPoint>(ZoneInputStream&)> entryPointFactory,
                                                             const unsigned pointerBitCount,
                                                             const unsigned offsetBlockBitCount,
-                                                            const block_t insertBlock)
+                                                            const block_t insertBlock,
+                                                            MemoryManager& memory)
     {
-        return std::make_unique<StepLoadZoneContent>(std::move(entryPointFactory), pointerBitCount, offsetBlockBitCount, insertBlock);
+        return std::make_unique<StepLoadZoneContent>(std::move(entryPointFactory), pointerBitCount, offsetBlockBitCount, insertBlock, memory);
     }
 } // namespace step
diff --git a/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h b/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h
index 536ef1a4..621fa2a2 100644
--- a/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h
+++ b/src/ZoneLoading/Loading/Steps/StepLoadZoneContent.h
@@ -12,5 +12,6 @@ namespace step
     std::unique_ptr<ILoadingStep> CreateStepLoadZoneContent(std::function<std::unique_ptr<IContentLoadingEntryPoint>(ZoneInputStream&)> entryPointFactory,
                                                             unsigned pointerBitCount,
                                                             unsigned offsetBlockBitCount,
-                                                            block_t insertBlock);
+                                                            block_t insertBlock,
+                                                            MemoryManager& memory);
 }
diff --git a/src/ZoneLoading/Zone/Stream/ZoneInputStream.cpp b/src/ZoneLoading/Zone/Stream/ZoneInputStream.cpp
index 572e8494..a7139d10 100644
--- a/src/ZoneLoading/Zone/Stream/ZoneInputStream.cpp
+++ b/src/ZoneLoading/Zone/Stream/ZoneInputStream.cpp
@@ -28,10 +28,15 @@ namespace
     class XBlockInputStream final : public ZoneInputStream
     {
     public:
-        XBlockInputStream(
-            const unsigned pointerBitCount, const unsigned blockBitCount, std::vector<XBlock*>& blocks, const block_t insertBlock, ILoadingStream& stream)
+        XBlockInputStream(const unsigned pointerBitCount,
+                          const unsigned blockBitCount,
+                          std::vector<XBlock*>& blocks,
+                          const block_t insertBlock,
+                          ILoadingStream& stream,
+                          MemoryManager& memory)
             : m_blocks(blocks),
               m_stream(stream),
+              m_memory(memory),
               m_pointer_byte_count(pointerBitCount / 8u),
               m_block_bit_count(blockBitCount)
         {
@@ -45,6 +50,11 @@ namespace
             m_insert_block = blocks[insertBlock];
         }
 
+        [[nodiscard]] unsigned GetPointerBitCount() const override
+        {
+            return m_pointer_byte_count * 8u;
+        }
+
         void PushBlock(const block_t block) override
         {
             assert(block < static_cast<block_t>(m_blocks.size()));
@@ -54,7 +64,7 @@ namespace
 
             m_block_stack.push(newBlock);
 
-            if (newBlock->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
+            if (newBlock->m_type == XBlockType::BLOCK_TYPE_TEMP)
                 m_temp_offsets.push(m_block_offsets[newBlock->m_index]);
         }
 
@@ -70,7 +80,7 @@ namespace
             m_block_stack.pop();
 
             // If the temp block is not used anymore right now, reset it to the buffer start since as the name suggests, the data inside is temporary.
-            if (poppedBlock->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
+            if (poppedBlock->m_type == XBlockType::BLOCK_TYPE_TEMP)
             {
                 m_block_offsets[poppedBlock->m_index] = m_temp_offsets.top();
                 m_temp_offsets.pop();
@@ -96,6 +106,23 @@ namespace
             return &block->m_buffer[m_block_offsets[block->m_index]];
         }
 
+        void* AllocOutOfBlock(const unsigned align, const size_t size) override
+        {
+            assert(!m_block_stack.empty());
+
+            if (m_block_stack.empty())
+                return nullptr;
+
+            auto* block = m_block_stack.top();
+
+            Align(align);
+
+            if (m_block_offsets[block->m_index] > block->m_buffer_size)
+                throw BlockOverflowException(block);
+
+            return m_memory.AllocRaw(size);
+        }
+
         void LoadDataRaw(void* dst, const size_t size) override
         {
             m_stream.Load(dst, size);
@@ -108,10 +135,10 @@ namespace
             {
                 auto* block = m_block_stack.top();
 
-                if (block->m_buffer > dst || block->m_buffer + block->m_buffer_size < dst)
+                if (block->m_buffer.get() > dst || block->m_buffer.get() + block->m_buffer_size < dst)
                     throw OutOfBlockBoundsException(block);
 
-                if (static_cast<uint8_t*>(dst) + size > block->m_buffer + block->m_buffer_size)
+                if (static_cast<uint8_t*>(dst) + size > block->m_buffer.get() + block->m_buffer_size)
                     throw BlockOverflowException(block);
 
                 // Theoretically ptr should always be at the current block offset.
@@ -119,16 +146,16 @@ namespace
 
                 switch (block->m_type)
                 {
-                case XBlock::Type::BLOCK_TYPE_TEMP:
-                case XBlock::Type::BLOCK_TYPE_NORMAL:
+                case XBlockType::BLOCK_TYPE_TEMP:
+                case XBlockType::BLOCK_TYPE_NORMAL:
                     m_stream.Load(dst, size);
                     break;
 
-                case XBlock::Type::BLOCK_TYPE_RUNTIME:
+                case XBlockType::BLOCK_TYPE_RUNTIME:
                     std::memset(dst, 0, size);
                     break;
 
-                case XBlock::Type::BLOCK_TYPE_DELAY:
+                case XBlockType::BLOCK_TYPE_DELAY:
                     assert(false);
                     break;
                 }
@@ -150,14 +177,14 @@ namespace
 
             auto* block = m_block_stack.top();
 
-            if (block->m_buffer > dst || block->m_buffer + block->m_buffer_size < dst)
+            if (block->m_buffer.get() > dst || block->m_buffer.get() + block->m_buffer_size < dst)
                 throw OutOfBlockBoundsException(block);
 
             // Theoretically ptr should always be at the current block offset.
             assert(dst == &block->m_buffer[m_block_offsets[block->m_index]]);
 
             uint8_t byte;
-            auto offset = static_cast<size_t>(static_cast<uint8_t*>(dst) - block->m_buffer);
+            auto offset = static_cast<size_t>(static_cast<uint8_t*>(dst) - block->m_buffer.get());
             do
             {
                 if (offset >= block->m_buffer_size)
@@ -181,16 +208,16 @@ namespace
                 const auto* block = m_block_stack.top();
                 switch (block->m_type)
                 {
-                case XBlock::Type::BLOCK_TYPE_TEMP:
-                case XBlock::Type::BLOCK_TYPE_NORMAL:
+                case XBlockType::BLOCK_TYPE_TEMP:
+                case XBlockType::BLOCK_TYPE_NORMAL:
                     m_stream.Load(dst, size);
                     break;
 
-                case XBlock::Type::BLOCK_TYPE_RUNTIME:
+                case XBlockType::BLOCK_TYPE_RUNTIME:
                     std::memset(dst, 0, size);
                     break;
 
-                case XBlock::Type::BLOCK_TYPE_DELAY:
+                case XBlockType::BLOCK_TYPE_DELAY:
                     assert(false);
                     break;
                 }
@@ -293,6 +320,8 @@ namespace
         std::stack<size_t> m_temp_offsets;
         ILoadingStream& m_stream;
 
+        MemoryManager& m_memory;
+
         unsigned m_pointer_byte_count;
         unsigned m_block_bit_count;
         XBlock* m_insert_block;
@@ -301,8 +330,12 @@ namespace
     };
 } // namespace
 
-std::unique_ptr<ZoneInputStream> ZoneInputStream::Create(
-    const unsigned pointerBitCount, const unsigned blockBitCount, std::vector<XBlock*>& blocks, const block_t insertBlock, ILoadingStream& stream)
+std::unique_ptr<ZoneInputStream> ZoneInputStream::Create(const unsigned pointerBitCount,
+                                                         const unsigned blockBitCount,
+                                                         std::vector<XBlock*>& blocks,
+                                                         const block_t insertBlock,
+                                                         ILoadingStream& stream,
+                                                         MemoryManager& memory)
 {
-    return std::make_unique<XBlockInputStream>(pointerBitCount, blockBitCount, blocks, insertBlock, stream);
+    return std::make_unique<XBlockInputStream>(pointerBitCount, blockBitCount, blocks, insertBlock, stream, memory);
 }
diff --git a/src/ZoneLoading/Zone/Stream/ZoneInputStream.h b/src/ZoneLoading/Zone/Stream/ZoneInputStream.h
index 8c7d0f26..82a322b5 100644
--- a/src/ZoneLoading/Zone/Stream/ZoneInputStream.h
+++ b/src/ZoneLoading/Zone/Stream/ZoneInputStream.h
@@ -1,10 +1,12 @@
 #pragma once
 
 #include "Loading/ILoadingStream.h"
+#include "Utils/MemoryManager.h"
 #include "Zone/Stream/IZoneStream.h"
 #include "Zone/XBlock.h"
 
 #include <cassert>
+#include <cstring>
 #include <memory>
 #include <vector>
 
@@ -47,6 +49,11 @@ private:
 class ZoneInputStream : public IZoneStream
 {
 public:
+    /**
+     * \brief Returns the configured bits that make up a pointer.
+     */
+    [[nodiscard]] virtual unsigned GetPointerBitCount() const = 0;
+
     /**
      * \brief Retrieves the new read position in the current block by aligning the position with the specified value and then returning the current read
      * position in the block.
@@ -64,6 +71,16 @@ public:
         return static_cast<T*>(Alloc(align));
     }
 
+    virtual void* AllocOutOfBlock(unsigned align, size_t size) = 0;
+
+    /**
+     * \copydoc ZoneInputStream#AllocOutOfBlock(unsigned)
+     */
+    template<typename T> T* AllocOutOfBlock(const unsigned align, const size_t arraySize = 1u)
+    {
+        return static_cast<T*>(AllocOutOfBlock(align, sizeof(T) * arraySize));
+    }
+
     /**
      * \brief Loads data from the underlying stream without considering the current block or advancing the block position.
      * The data is read directly to the specified location instead of block memory.
@@ -120,6 +137,6 @@ public:
         return static_cast<T*>(ConvertOffsetToAliasNative(static_cast<const void*>(offset)));
     }
 
-    static std::unique_ptr<ZoneInputStream>
-        Create(unsigned pointerBitCount, unsigned blockBitCount, std::vector<XBlock*>& blocks, block_t insertBlock, ILoadingStream& stream);
+    static std::unique_ptr<ZoneInputStream> Create(
+        unsigned pointerBitCount, unsigned blockBitCount, std::vector<XBlock*>& blocks, block_t insertBlock, ILoadingStream& stream, MemoryManager& memory);
 };
diff --git a/src/ZoneWriting/Game/IW3/ZoneWriterFactoryIW3.cpp b/src/ZoneWriting/Game/IW3/ZoneWriterFactoryIW3.cpp
index 9fb99f06..2621980c 100644
--- a/src/ZoneWriting/Game/IW3/ZoneWriterFactoryIW3.cpp
+++ b/src/ZoneWriting/Game/IW3/ZoneWriterFactoryIW3.cpp
@@ -22,15 +22,15 @@ namespace
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
-        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(IW3::XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
diff --git a/src/ZoneWriting/Game/IW4/ZoneWriterFactoryIW4.cpp b/src/ZoneWriting/Game/IW4/ZoneWriterFactoryIW4.cpp
index ede84059..0bb35364 100644
--- a/src/ZoneWriting/Game/IW4/ZoneWriterFactoryIW4.cpp
+++ b/src/ZoneWriting/Game/IW4/ZoneWriterFactoryIW4.cpp
@@ -24,14 +24,14 @@ namespace
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
diff --git a/src/ZoneWriting/Game/IW5/ZoneWriterFactoryIW5.cpp b/src/ZoneWriting/Game/IW5/ZoneWriterFactoryIW5.cpp
index 4ed62b7d..00338ed7 100644
--- a/src/ZoneWriting/Game/IW5/ZoneWriterFactoryIW5.cpp
+++ b/src/ZoneWriting/Game/IW5/ZoneWriterFactoryIW5.cpp
@@ -24,15 +24,15 @@ namespace
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_SCRIPT, XBlock::Type::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_CALLBACK, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_VERTEX, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_INDEX, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(XFILE_BLOCK_SCRIPT, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
diff --git a/src/ZoneWriting/Game/T5/ZoneWriterFactoryT5.cpp b/src/ZoneWriting/Game/T5/ZoneWriterFactoryT5.cpp
index c96c6599..cd5ca5bf 100644
--- a/src/ZoneWriting/Game/T5/ZoneWriterFactoryT5.cpp
+++ b/src/ZoneWriting/Game/T5/ZoneWriterFactoryT5.cpp
@@ -22,13 +22,13 @@ namespace
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
-        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL_RUNTIME, XBlockType::BLOCK_TYPE_RUNTIME));
+        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_LARGE, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(T5::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
diff --git a/src/ZoneWriting/Game/T6/ZoneWriterFactoryT6.cpp b/src/ZoneWriting/Game/T6/ZoneWriterFactoryT6.cpp
index ffa5edf6..3d0d1d70 100644
--- a/src/ZoneWriting/Game/T6/ZoneWriterFactoryT6.cpp
+++ b/src/ZoneWriting/Game/T6/ZoneWriterFactoryT6.cpp
@@ -29,14 +29,14 @@ namespace
     {
 #define XBLOCK_DEF(name, type) std::make_unique<XBlock>(STR(name), name, type)
 
-        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_TEMP, XBlock::Type::BLOCK_TYPE_TEMP));
-        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_VIRTUAL, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_PHYSICAL, XBlock::Type::BLOCK_TYPE_RUNTIME));
-        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_VIRTUAL, XBlock::Type::BLOCK_TYPE_DELAY));
-        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_PHYSICAL, XBlock::Type::BLOCK_TYPE_DELAY));
-        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_VIRTUAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_PHYSICAL, XBlock::Type::BLOCK_TYPE_NORMAL));
-        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_STREAMER_RESERVE, XBlock::Type::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_TEMP, XBlockType::BLOCK_TYPE_TEMP));
+        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_VIRTUAL, XBlockType::BLOCK_TYPE_RUNTIME));
+        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_RUNTIME_PHYSICAL, XBlockType::BLOCK_TYPE_RUNTIME));
+        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_VIRTUAL, XBlockType::BLOCK_TYPE_DELAY));
+        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_DELAY_PHYSICAL, XBlockType::BLOCK_TYPE_DELAY));
+        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_VIRTUAL, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_PHYSICAL, XBlockType::BLOCK_TYPE_NORMAL));
+        writer.AddXBlock(XBLOCK_DEF(T6::XFILE_BLOCK_STREAMER_RESERVE, XBlockType::BLOCK_TYPE_NORMAL));
 
 #undef XBLOCK_DEF
     }
diff --git a/src/ZoneWriting/Zone/Stream/Impl/InMemoryZoneOutputStream.cpp b/src/ZoneWriting/Zone/Stream/Impl/InMemoryZoneOutputStream.cpp
index a1f3760d..6eff9d3f 100644
--- a/src/ZoneWriting/Zone/Stream/Impl/InMemoryZoneOutputStream.cpp
+++ b/src/ZoneWriting/Zone/Stream/Impl/InMemoryZoneOutputStream.cpp
@@ -30,7 +30,7 @@ void InMemoryZoneOutputStream::PushBlock(const block_t block)
 
     m_block_stack.push(newBlock);
 
-    if (newBlock->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
+    if (newBlock->m_type == XBlockType::BLOCK_TYPE_TEMP)
     {
         if (m_temp_sizes.empty())
             m_temp_sizes.push(0);
@@ -50,7 +50,7 @@ block_t InMemoryZoneOutputStream::PopBlock()
     m_block_stack.pop();
 
     // If temp block is popped, see if its size is bigger than the current maximum temp size
-    if (poppedBlock->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
+    if (poppedBlock->m_type == XBlockType::BLOCK_TYPE_TEMP)
     {
         const auto tempSize = m_temp_sizes.top();
         m_temp_sizes.pop();
@@ -70,7 +70,7 @@ void InMemoryZoneOutputStream::Align(const int align)
     {
         auto* block = m_block_stack.top();
 
-        if (block->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
+        if (block->m_type == XBlockType::BLOCK_TYPE_TEMP)
             m_temp_sizes.top() = (m_temp_sizes.top() + align - 1) / align * align;
         else
             block->m_buffer_size = (block->m_buffer_size + align - 1) / align * align;
@@ -96,16 +96,16 @@ void* InMemoryZoneOutputStream::WriteDataInBlock(const void* src, const size_t s
     void* result = nullptr;
     switch (block->m_type)
     {
-    case XBlock::Type::BLOCK_TYPE_TEMP:
-    case XBlock::Type::BLOCK_TYPE_NORMAL:
+    case XBlockType::BLOCK_TYPE_TEMP:
+    case XBlockType::BLOCK_TYPE_NORMAL:
         result = m_zone_data->GetBufferOfSize(size);
         memcpy(result, src, size);
         break;
 
-    case XBlock::Type::BLOCK_TYPE_RUNTIME:
+    case XBlockType::BLOCK_TYPE_RUNTIME:
         break;
 
-    case XBlock::Type::BLOCK_TYPE_DELAY:
+    case XBlockType::BLOCK_TYPE_DELAY:
         assert(false);
         break;
     }
@@ -122,7 +122,7 @@ void InMemoryZoneOutputStream::IncBlockPos(const size_t size)
         return;
 
     auto* block = m_block_stack.top();
-    if (block->m_type == XBlock::Type::BLOCK_TYPE_TEMP)
+    if (block->m_type == XBlockType::BLOCK_TYPE_TEMP)
     {
         m_temp_sizes.top() += size;
     }
@@ -141,7 +141,7 @@ void InMemoryZoneOutputStream::WriteNullTerminated(const void* src)
 uintptr_t InMemoryZoneOutputStream::GetCurrentZonePointer()
 {
     assert(!m_block_stack.empty());
-    assert(m_block_stack.top()->m_type == XBlock::Type::BLOCK_TYPE_NORMAL);
+    assert(m_block_stack.top()->m_type == XBlockType::BLOCK_TYPE_NORMAL);
 
     uintptr_t ptr = 0;
     ptr |= static_cast<uintptr_t>(m_block_stack.top()->m_index) << (sizeof(uintptr_t) * 8 - m_block_bit_count);
@@ -168,7 +168,7 @@ void InMemoryZoneOutputStream::MarkFollowing(void** pPtr)
 {
     assert(!m_block_stack.empty());
     assert(pPtr != nullptr);
-    *pPtr = m_block_stack.top()->m_type == XBlock::Type::BLOCK_TYPE_TEMP ? PTR_INSERT : PTR_FOLLOWING;
+    *pPtr = m_block_stack.top()->m_type == XBlockType::BLOCK_TYPE_TEMP ? PTR_INSERT : PTR_FOLLOWING;
 }
 
 bool InMemoryZoneOutputStream::ReusableShouldWrite(void** pPtr, const size_t entrySize, const std::type_index type)
@@ -202,7 +202,7 @@ void InMemoryZoneOutputStream::ReusableAddOffset(void* ptr, size_t size, size_t
 {
     assert(!m_block_stack.empty());
 
-    const auto inTemp = m_block_stack.top()->m_type == XBlock::Type::BLOCK_TYPE_TEMP;
+    const auto inTemp = m_block_stack.top()->m_type == XBlockType::BLOCK_TYPE_TEMP;
     auto zoneOffset = inTemp ? InsertPointer() : GetCurrentZonePointer();
     const auto foundEntriesForType = m_reusable_entries.find(type);
     if (foundEntriesForType == m_reusable_entries.end())