The decomp is compiling!

src/codsrc/clientscript/clientscript_public.hpp

@@ -1,3 +1,11 @@
 #pragma once
 
 #include "cscr_main.hpp"
+#include "cscr_memorytree.hpp"
+#include "cscr_parser.hpp"
+#include "cscr_parsetree.hpp"
+#include "cscr_readwrite.hpp"
+#include "cscr_stringlist.hpp"
+#include "cscr_tempmemory.hpp"
+#include "cscr_variable.hpp"
+#include "cscr_vm.hpp"

src/codsrc/clientscript/cscr_memorytree.cpp

@@ -0,0 +1,525 @@
+#include <stdinc.hpp>
+#include "clientscript_public.hpp"
+
+namespace codsrc
+{
+	// Restored
+	game::RefVector* GetRefVector(game::scriptInstance_t inst, unsigned int id)
+	{
+		assert(id);
+
+		assert((id * MT_NODE_SIZE) < MT_SIZE);
+
+		return (game::RefVector*)&game::gScrMemTreePub[inst].mt_buffer->nodes[id];
+	}
+
+	// Decomp Status: Tested, Completed
+	int MT_GetSubTreeSize(game::scriptInstance_t inst, int nodeNum)
+	{
+		int treeSize;
+
+		if (nodeNum)
+		{
+			treeSize = game::MT_GetSubTreeSize(inst, game::gScrMemTreeGlob[inst].nodes[nodeNum].next);
+			return treeSize + game::MT_GetSubTreeSize(inst, game::gScrMemTreeGlob[inst].nodes[nodeNum].prev) + 1;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+
+	// Decomp Status: Tested, Completed
+	void MT_DumpTree(game::scriptInstance_t inst)
+	{
+		int size;
+
+		//assert(game::gScrMemTreeGlob[inst].totalAlloc == totalAlloc);
+		//assert(game::gScrMemTreeGlob[inst].totalAllocBuckets == totalAllocBuckets);
+
+		game::Com_Printf(game::CON_CHANNEL_PARSERSCRIPT, "********************************\n");
+		for (int i = 0; i <= MT_NODE_BITS; ++i)
+		{
+			size = game::MT_GetSubTreeSize(inst, game::gScrMemTreeGlob[inst].head[i]);
+			game::Com_Printf(game::CON_CHANNEL_PARSERSCRIPT, "%d subtree has %d * %d = %d free buckets\n", i, size, 1 << i, size << i);
+		}
+		game::Com_Printf(game::CON_CHANNEL_PARSERSCRIPT, "********************************\n");
+		game::Com_Printf(game::CON_CHANNEL_PARSERSCRIPT, "********************************\n");
+		game::Com_Printf(game::CON_CHANNEL_PARSERSCRIPT, "********************************\n");
+
+		//assert(totalBuckets == (1 << MEMORY_NODE_BITS) - 1);
+	}
+
+	// Decomp Status: Tested, Completed
+	void MT_InitBits(game::scriptInstance_t inst)
+	{
+		char bits;
+		int temp;
+		int i;
+
+		for (i = 0; i < MT_NUM_BUCKETS; ++i)
+		{
+			bits = 0;
+
+			for (temp = i; temp; temp >>= 1)
+			{
+				if (temp & 1)
+				{
+					++bits;
+				}
+			}
+
+			game::gScrMemTreeGlob[inst].numBits[i] = bits;
+
+			for (bits = 8; i & ((1 << bits) - 1); --bits);
+
+			game::gScrMemTreeGlob[inst].leftBits[i] = bits;
+			bits = 0;
+
+			for (temp = i; temp; temp >>= 1)
+			{
+				++bits;
+			}
+
+			game::gScrMemTreeGlob[inst].logBits[i] = bits;
+		}
+	}
+
+	// Decomp Status: Tested, Completed
+	int MT_GetScore(game::scriptInstance_t inst, int num)
+	{
+		char bits;
+
+		union MTnum_t
+		{
+			int i;
+			uint8_t b[4];
+		};
+
+		assert(num);
+
+		assert(MT_NODE_COUNT - num);
+
+		MTnum_t mtnum;
+
+		mtnum.i = MT_NODE_COUNT - num;
+
+		bits = game::gScrMemTreeGlob[inst].leftBits[mtnum.b[0]];
+
+		if (!mtnum.b[0])
+		{
+			bits += game::gScrMemTreeGlob[inst].leftBits[mtnum.b[1]];
+		}
+
+		return mtnum.i - (game::gScrMemTreeGlob[inst].numBits[mtnum.b[1]] + game::gScrMemTreeGlob[inst].numBits[mtnum.b[0]]) + (1 << bits);
+	}
+
+	// Decomp Status: Tested, Completed
+	void MT_AddMemoryNode(game::scriptInstance_t inst, int newNode, int size)
+	{
+		int node;
+		int nodeNum;
+		int newScore;
+		uint16_t* parentNode;
+		int level;
+		int score;
+
+		assert(size >= 0 && size <= MT_NODE_BITS);
+
+		parentNode = &game::gScrMemTreeGlob[inst].head[size];
+		node = game::gScrMemTreeGlob[inst].head[size];
+		if (game::gScrMemTreeGlob[inst].head[size])
+		{
+			newScore = game::MT_GetScore(inst, newNode);
+			nodeNum = 0;
+			level = MT_NODE_COUNT;
+			do
+			{
+				assert(newNode != node);
+
+				score = game::MT_GetScore(inst, node);
+
+				assert(score != newScore);
+
+				if (score < newScore)
+				{
+					while (1)
+					{
+						*parentNode = (short)newNode;
+						game::gScrMemTreeGlob[inst].nodes[newNode] = game::gScrMemTreeGlob[inst].nodes[node];
+						if (!node)
+						{
+							break;
+						}
+						level >>= 1;
+
+						assert(node != nodeNum);
+
+						if (node >= nodeNum)
+						{
+							parentNode = &game::gScrMemTreeGlob[inst].nodes[newNode].next;
+							nodeNum += level;
+						}
+						else
+						{
+							parentNode = &game::gScrMemTreeGlob[inst].nodes[newNode].prev;
+							nodeNum -= level;
+						}
+
+						newNode = node;
+						node = *parentNode;
+					}
+					return;
+				}
+				level >>= 1;
+
+				assert(newNode != nodeNum);
+
+				if (newNode >= nodeNum)
+				{
+					parentNode = &game::gScrMemTreeGlob[inst].nodes[node].next;
+					nodeNum += level;
+				}
+				else
+				{
+					parentNode = &game::gScrMemTreeGlob[inst].nodes[node].prev;
+					nodeNum -= level;
+				}
+
+				node = *parentNode;
+			} while (node);
+		}
+
+		*parentNode = (short)newNode;
+
+		game::gScrMemTreeGlob[inst].nodes[newNode].prev = 0;
+		game::gScrMemTreeGlob[inst].nodes[newNode].next = 0;
+	}
+
+	// Decomp Status: Tested, Completed
+	char MT_RemoveMemoryNode(game::scriptInstance_t inst, int oldNode, int size)
+	{
+		game::MemoryNode tempNodeValue;
+		int node;
+		game::MemoryNode oldNodeValue;
+		int nodeNum;
+		uint16_t* parentNode;
+		int prevScore;
+		int nextScore;
+		int level;
+
+		assert(size >= 0 && size <= MT_NODE_BITS);
+
+		nodeNum = 0;
+		level = MT_NODE_COUNT;
+		parentNode = &game::gScrMemTreeGlob[inst].head[size];
+
+		for (node = *parentNode; node; node = *parentNode)
+		{
+			if (oldNode == node)
+			{
+				oldNodeValue = game::gScrMemTreeGlob[inst].nodes[oldNode];
+
+				while (1)
+				{
+					if (oldNodeValue.prev)
+					{
+						if (oldNodeValue.next)
+						{
+							prevScore = game::MT_GetScore(inst, oldNodeValue.prev);
+							nextScore = game::MT_GetScore(inst, oldNodeValue.next);
+
+							assert(prevScore != nextScore);
+
+							if (prevScore >= nextScore)
+							{
+								oldNode = oldNodeValue.prev;
+								*parentNode = oldNodeValue.prev;
+								parentNode = &game::gScrMemTreeGlob[inst].nodes[oldNodeValue.prev].prev;
+							}
+							else
+							{
+								oldNode = oldNodeValue.next;
+								*parentNode = oldNodeValue.next;
+								parentNode = &game::gScrMemTreeGlob[inst].nodes[oldNodeValue.next].next;
+							}
+						}
+						else
+						{
+							oldNode = oldNodeValue.prev;
+							*parentNode = oldNodeValue.prev;
+							parentNode = &game::gScrMemTreeGlob[inst].nodes[oldNodeValue.prev].prev;
+						}
+					}
+					else
+					{
+						oldNode = oldNodeValue.next;
+						*parentNode = oldNodeValue.next;
+
+						if (!oldNodeValue.next)
+						{
+							return true;
+						}
+
+						parentNode = &game::gScrMemTreeGlob[inst].nodes[oldNodeValue.next].next;
+					}
+
+					assert(oldNode);
+
+					tempNodeValue = oldNodeValue;
+					oldNodeValue = game::gScrMemTreeGlob[inst].nodes[oldNode];
+					game::gScrMemTreeGlob[inst].nodes[oldNode] = tempNodeValue;
+				}
+			}
+
+			if (oldNode == nodeNum)
+			{
+				return false;
+			}
+
+			level >>= 1;
+
+			if (oldNode >= nodeNum)
+			{
+				parentNode = &game::gScrMemTreeGlob[inst].nodes[node].next;
+				nodeNum += level;
+			}
+			else
+			{
+				parentNode = &game::gScrMemTreeGlob[inst].nodes[node].prev;
+				nodeNum -= level;
+			}
+		}
+
+		return false;
+	}
+
+	// Decomp Status: Tested, Completed
+	void MT_RemoveHeadMemoryNode(game::scriptInstance_t inst, int size)
+	{
+		game::MemoryNode tempNodeValue;
+		int oldNode;
+		game::MemoryNode oldNodeValue;
+		uint16_t* parentNode;
+		int prevScore;
+		int nextScore;
+
+		assert(size >= 0 && size <= MT_NODE_BITS);
+
+		parentNode = &game::gScrMemTreeGlob[inst].head[size];
+		oldNodeValue = game::gScrMemTreeGlob[inst].nodes[*parentNode];
+
+		while (1)
+		{
+			if (!oldNodeValue.prev)
+			{
+				oldNode = oldNodeValue.next;
+				*parentNode = oldNodeValue.next;
+				if (!oldNode)
+				{
+					break;
+				}
+				parentNode = &game::gScrMemTreeGlob[inst].nodes[oldNode].next;
+			}
+			else
+			{
+				if (oldNodeValue.next)
+				{
+					prevScore = game::MT_GetScore(inst, oldNodeValue.prev);
+					nextScore = game::MT_GetScore(inst, oldNodeValue.next);
+
+					assert(prevScore != nextScore);
+
+					if (prevScore >= nextScore)
+					{
+						oldNode = oldNodeValue.prev;
+						*parentNode = (short)oldNode;
+						parentNode = &game::gScrMemTreeGlob[inst].nodes[oldNode].prev;
+					}
+					else
+					{
+						oldNode = oldNodeValue.next;
+						*parentNode = (short)oldNode;
+						parentNode = &game::gScrMemTreeGlob[inst].nodes[oldNode].next;
+					}
+				}
+				else
+				{
+					oldNode = oldNodeValue.prev;
+					*parentNode = (short)oldNode;
+					parentNode = &game::gScrMemTreeGlob[inst].nodes[oldNode].prev;
+				}
+			}
+			assert(oldNode != 0);
+
+			tempNodeValue = oldNodeValue;
+			oldNodeValue = game::gScrMemTreeGlob[inst].nodes[oldNode];
+			game::gScrMemTreeGlob[inst].nodes[oldNode] = tempNodeValue;
+		}
+	}
+
+	// Decomp Status: Tested, Completed
+	void MT_Init(game::scriptInstance_t inst)
+	{
+		game::Sys_EnterCriticalSection(game::CRITSECT_MEMORY_TREE);
+
+		game::scrMemTreeGlob_t* memTreeBuffer = &game::gScrMemTreeGlob[inst];
+		game::gScrMemTreePub[inst].mt_buffer = memTreeBuffer;
+
+		game::MT_InitBits(inst);
+
+		for (int i = 0; i <= MT_NODE_BITS; ++i)
+		{
+			memTreeBuffer->head[i] = 0;
+		}
+
+		memTreeBuffer->nodes[0].next = 0;
+		memTreeBuffer->nodes[0].prev = 0;
+
+		for (int i = 0; i < MT_NODE_BITS; ++i)
+		{
+			game::MT_AddMemoryNode(inst, 1 << i, i);
+		}
+
+		game::Sys_LeaveCriticalSection(game::CRITSECT_MEMORY_TREE);
+	}
+
+	// Decomp Status: Tested, Completed
+	void MT_Error(game::scriptInstance_t inst, const char* funcName, int numBytes)
+	{
+		game::MT_DumpTree(inst);
+		game::Com_Printf(game::CON_CHANNEL_PARSERSCRIPT, "%s: failed memory allocation of %d bytes for script usage\n", funcName, numBytes);
+		game::Scr_DumpScriptThreads(inst);
+		game::gScrVmPub[inst].terminal_error = 1;
+		game::Scr_Error("failed memory allocation for script usage", inst, 0);
+	}
+
+	// Decomp Status: Tested, Completed
+	int MT_GetSize(int numBytes, game::scriptInstance_t inst)
+	{
+		int numBuckets;
+		int result;
+
+		assert(numBytes > 0);
+
+		if (numBytes >= MT_NODE_COUNT)
+		{
+			game::MT_Error(inst, "MT_GetSize: max allocation exceeded", numBytes);
+			result = 0;
+		}
+		else
+		{
+			numBuckets = (numBytes + MT_NODE_SIZE - 1) / MT_NODE_SIZE - 1;
+			if (numBuckets > MT_NUM_BUCKETS - 1)
+			{
+				result = game::gScrMemTreeGlob[inst].logBits[numBuckets >> 8] + 8;
+			}
+			else
+			{
+				result = game::gScrMemTreeGlob[inst].logBits[numBuckets];
+			}
+		}
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	unsigned __int16 MT_AllocIndex(game::scriptInstance_t inst, int numBytes)
+	{
+		int nodeNum;
+		int size = game::MT_GetSize(numBytes, inst);
+		int newSize;
+
+		assert(size >= 0 && size <= MT_NODE_BITS);
+
+		game::Sys_EnterCriticalSection(game::CRITSECT_MEMORY_TREE);
+
+		for (newSize = size; ; ++newSize)
+		{
+			if (newSize > MT_NODE_BITS)
+			{
+				game::Sys_LeaveCriticalSection(game::CRITSECT_MEMORY_TREE);
+				game::MT_Error(inst, "MT_AllocIndex", numBytes);
+				return 0;
+			}
+			nodeNum = game::gScrMemTreeGlob[inst].head[newSize];
+			if (game::gScrMemTreeGlob[inst].head[newSize])
+			{
+				break;
+			}
+		}
+
+		game::MT_RemoveHeadMemoryNode(inst, newSize);
+
+		while (newSize != size)
+		{
+			--newSize;
+			game::MT_AddMemoryNode(inst, nodeNum + (1 << newSize), newSize);
+		}
+
+		//assert(type);
+
+		//assert(!game::gScrMemTreeDebugGlob[inst].mt_usage[nodeNum]);
+
+		//assert(!game::gScrMemTreeDebugGlob[inst].mt_usage_size[nodeNum]);
+
+		game::Sys_LeaveCriticalSection(game::CRITSECT_MEMORY_TREE);
+		return (short)nodeNum;
+	}
+
+	// Decomp Status: Tested, Completed
+	void MT_FreeIndex(int numBytes, game::scriptInstance_t inst, int nodeNum)
+	{
+		int size = game::MT_GetSize(numBytes, inst);
+
+		assert(size >= 0 && size <= MT_NODE_BITS);
+
+		assert(nodeNum > 0 && nodeNum < MT_NODE_COUNT);
+
+		game::Sys_EnterCriticalSection(game::CRITSECT_MEMORY_TREE);
+
+		//assert(game::gScrMemTreeDebugGlob[inst].mt_usage[nodeNum]);
+
+		//assert(game::gScrMemTreeDebugGlob[inst].mt_usage_size[nodeNum] == size);
+
+		for (int i = 1 << size; size != MT_NODE_BITS; i = 1 << ++size)
+		{
+			assert(size <= MT_NODE_BITS);
+
+			assert(nodeNum == (nodeNum & ~((1 << size) - 1)));
+
+			if (!game::MT_RemoveMemoryNode(inst, nodeNum ^ i, size))
+			{
+				break;
+			}
+			nodeNum &= ~i;
+		}
+		game::MT_AddMemoryNode(inst, nodeNum, size);
+
+		game::Sys_LeaveCriticalSection(game::CRITSECT_MEMORY_TREE);
+	}
+
+	// Decomp Status: Tested, Completed
+	char* MT_Alloc(int numBytes, game::scriptInstance_t inst)
+	{
+		return (char*)(game::gScrMemTreeGlob[inst].nodes + game::MT_AllocIndex(inst, numBytes));
+	}
+
+	// Decomp Status: Tested, Completed
+	void MT_Free(void* p, int numBytes, game::scriptInstance_t inst)
+	{
+		assert((game::MemoryNode*)p - game::gScrMemTreeGlob[inst].nodes >= 0 && (game::MemoryNode*)p - game::gScrMemTreeGlob[inst].nodes < MT_NODE_COUNT);
+
+		game::MT_FreeIndex(numBytes, inst, (game::MemoryNode*)p - game::gScrMemTreeGlob[inst].nodes);
+	}
+
+	// Restored inlined function
+	char* MT_GetRefByIndex(game::scriptInstance_t inst, int index)
+	{
+		if (index > MT_NODE_COUNT)
+		{
+			game::MT_Error(inst, "MT_GetRefByIndex: out of bounds index", index);
+			return NULL;
+		}
+		return (char*)&game::gScrMemTreeGlob[inst].nodes[index];
+	}
+}

src/codsrc/clientscript/cscr_memorytree.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+namespace codsrc
+{
+	game::RefVector* GetRefVector(game::scriptInstance_t inst, unsigned int id);
+	int MT_GetSubTreeSize(game::scriptInstance_t inst, int nodeNum);
+	void MT_DumpTree(game::scriptInstance_t inst);
+	void MT_InitBits(game::scriptInstance_t inst);
+	int MT_GetScore(game::scriptInstance_t inst, int num);
+	void MT_AddMemoryNode(game::scriptInstance_t inst, int newNode, int size);
+	char MT_RemoveMemoryNode(game::scriptInstance_t inst, int oldNode, int size);
+	void MT_RemoveHeadMemoryNode(game::scriptInstance_t inst, int size);
+	void MT_Init(game::scriptInstance_t inst);
+	void MT_Error(game::scriptInstance_t inst, const char* funcName, int numBytes);
+	int MT_GetSize(int numBytes, game::scriptInstance_t inst);
+	unsigned __int16 MT_AllocIndex(game::scriptInstance_t inst, int numBytes);
+	void MT_FreeIndex(int numBytes, game::scriptInstance_t inst, int nodeNum);
+	char* MT_Alloc(int numBytes, game::scriptInstance_t inst);
+	void MT_Free(void* p, int numBytes, game::scriptInstance_t inst);
+	const char* MT_NodeInfoString(game::scriptInstance_t inst, unsigned int nodeNum);
+}

src/codsrc/clientscript/cscr_parser.cpp

@@ -0,0 +1,917 @@
+#include <stdinc.hpp>
+#include "clientscript_public.hpp"
+
+namespace codsrc
+{
+    // Decomp Status: Tested, Completed
+    void Scr_InitOpcodeLookup(game::scriptInstance_t inst)
+    {
+        unsigned int opcodeLookupMaxLen;
+        game::OpcodeLookup* opcodeLookup;
+        unsigned int sourcePosLookupMaxLen;
+        game::HunkUser* debugHunkUser;
+        unsigned int sourceBufferLookupMaxLen;
+
+        assert(!game::gScrParserGlob[inst].opcodeLookup);
+
+        assert(!game::gScrParserGlob[inst].sourcePosLookup);
+
+        assert(!game::gScrParserPub[inst].sourceBufferLookup);
+
+        if (game::gScrVarPub[inst].developer)
+        {
+            debugHunkUser = (game::HunkUser*)game::g_DebugHunkUser.get();
+            opcodeLookupMaxLen = inst != game::SCRIPTINSTANCE_CLIENT ? 0x40000 : 0x4000;
+            game::gScrParserGlob[inst].opcodeLookupMaxLen = opcodeLookupMaxLen;
+            game::gScrParserGlob[inst].delayedSourceIndex = -1;
+            game::gScrParserGlob[inst].opcodeLookupLen = 0;
+            opcodeLookup = (game::OpcodeLookup*)game::Hunk_UserAlloc(debugHunkUser, 24 * opcodeLookupMaxLen, 4);
+            game::gScrParserGlob[inst].opcodeLookup = opcodeLookup;
+
+            memset(opcodeLookup, 0, sizeof(game::OpcodeLookup) * game::gScrParserGlob[inst].opcodeLookupMaxLen);
+
+            sourcePosLookupMaxLen = inst != game::SCRIPTINSTANCE_CLIENT ? 0x60000 : 0x10;
+            game::gScrParserGlob[inst].sourcePosLookupMaxLen = sourcePosLookupMaxLen;
+            game::gScrParserGlob[inst].sourcePosLookupLen = 0;
+            game::gScrParserGlob[inst].sourcePosLookup = (game::SourceLookup*)game::Hunk_UserAlloc(debugHunkUser, 8 * sourcePosLookupMaxLen, 4);
+            sourceBufferLookupMaxLen = inst != game::SCRIPTINSTANCE_CLIENT ? 0x100 : 0x10;
+            game::gScrParserGlob[inst].sourceBufferLookupMaxLen = sourceBufferLookupMaxLen;
+            game::gScrParserGlob[inst].currentCodePos = 0;
+            game::gScrParserGlob[inst].currentSourcePosCount = 0;
+            game::gScrParserPub[inst].sourceBufferLookupLen = 0;
+            game::gScrParserPub[inst].sourceBufferLookup = (game::SourceBufferInfo*)game::Hunk_UserAlloc(debugHunkUser, 24 * sourceBufferLookupMaxLen, 4);
+        }
+    }
+
+    // Decomp Status: Tested, Completed
+    void Scr_ShutdownOpcodeLookup(game::scriptInstance_t inst)
+    {
+        if (game::gScrParserGlob[inst].opcodeLookup)
+        {
+            game::gScrParserGlob[inst].opcodeLookup = 0;
+        }
+        if (game::gScrParserGlob[inst].sourcePosLookup)
+        {
+            game::gScrParserGlob[inst].sourcePosLookup = 0;
+        }
+        if (game::gScrParserPub[inst].sourceBufferLookup != 0)
+        {
+            game::gScrParserPub[inst].sourceBufferLookup = 0;
+        }
+        if (game::gScrParserGlob[inst].saveSourceBufferLookup)
+        {
+            game::gScrParserGlob[inst].saveSourceBufferLookup = 0;
+        }
+    }
+
+    // Decomp Status: Completed
+    void AddOpcodePos(game::scriptInstance_t inst, unsigned int sourcePos, int type)
+    {
+        game::OpcodeLookup* newOpcodeLookup;
+        game::SourceLookup* newSourcePosLookup;
+        char* compilerOpcodePos;
+        game::OpcodeLookup* opcodeLookup;
+        int posIndex;
+        game::SourceLookup* sourcePosLookup;
+        int delayedSourceIndex;
+        int allocSize;
+
+        if (game::gScrVarPub[inst].developer)
+        {
+            if (game::gScrCompilePub[inst].developer_statement != 2)
+            {
+                if (!game::gScrCompilePub[inst].allowedBreakpoint)
+                {
+                    type &= ~1u;
+                }
+
+                assert(game::gScrParserGlob[inst].opcodeLookup);
+
+                assert(game::gScrParserGlob[inst].opcodeLookupMaxLen);
+
+                assert(game::gScrParserGlob[inst].sourcePosLookup);
+
+                assert(game::gScrCompilePub[inst].opcodePos);
+
+                if (game::gScrParserGlob[inst].opcodeLookupLen >= game::gScrParserGlob[inst].opcodeLookupMaxLen)
+                {
+                    allocSize = (sizeof(game::OpcodeLookup) * 2) * game::gScrParserGlob[inst].opcodeLookupMaxLen;
+                    game::gScrParserGlob[inst].opcodeLookupMaxLen *= 2;
+
+                    assert(game::gScrParserGlob[inst].opcodeLookupLen < game::gScrParserGlob[inst].opcodeLookupMaxLen);
+
+                    newOpcodeLookup = (game::OpcodeLookup*)game::Hunk_UserAlloc((game::HunkUser*)game::g_DebugHunkUser.get(), allocSize, 4);
+                    memcpy(newOpcodeLookup, game::gScrParserGlob[inst].opcodeLookup, sizeof(game::OpcodeLookup) * game::gScrParserGlob[inst].opcodeLookupLen);
+                    game::gScrParserGlob[inst].opcodeLookup = newOpcodeLookup;
+                }
+
+                if (game::gScrParserGlob[inst].sourcePosLookupLen >= game::gScrParserGlob[inst].sourcePosLookupMaxLen)
+                {
+                    allocSize = (sizeof(game::SourceLookup) * 2) * game::gScrParserGlob[inst].sourcePosLookupMaxLen;
+                    game::gScrParserGlob[inst].sourcePosLookupMaxLen *= 2;
+
+                    assert(game::gScrParserGlob[inst].sourcePosLookupLen < game::gScrParserGlob[inst].sourcePosLookupMaxLen);
+
+                    newSourcePosLookup = (game::SourceLookup*)game::Hunk_UserAlloc((game::HunkUser*)game::g_DebugHunkUser.get(), allocSize, 4);
+                    memcpy(newSourcePosLookup, game::gScrParserGlob[inst].sourcePosLookup, sizeof(game::SourceLookup) * game::gScrParserGlob[inst].sourcePosLookupLen);
+                    game::gScrParserGlob[inst].sourcePosLookup = newSourcePosLookup;
+                }
+
+                compilerOpcodePos = game::gScrCompilePub[inst].opcodePos;
+                if ((char*)game::gScrParserGlob[inst].currentCodePos == compilerOpcodePos)
+                {
+                    //assert(game::gScrParserGlob[inst].currentSourcePosCount);
+
+                    opcodeLookup = &game::gScrParserGlob[inst].opcodeLookup[--game::gScrParserGlob[inst].opcodeLookupLen];
+
+                    //assert(opcodeLookup->sourcePosIndex + game::gScrParserGlob[inst].currentSourcePosCount == game::gScrParserGlob[inst].sourcePosLookupLen);
+
+                    //assert(opcodeLookup->codePos == (char*)game::gScrParserGlob[inst].currentCodePos);
+                }
+                else
+                {
+                    game::gScrParserGlob[inst].currentCodePos = (const unsigned char*)compilerOpcodePos;
+                    opcodeLookup = &game::gScrParserGlob[inst].opcodeLookup[game::gScrParserGlob[inst].opcodeLookupLen];
+                    game::gScrParserGlob[inst].currentSourcePosCount = 0;
+                    opcodeLookup->sourcePosIndex = game::gScrParserGlob[inst].sourcePosLookupLen;
+                    opcodeLookup->codePos = (const char*)game::gScrParserGlob[inst].currentCodePos;
+                }
+
+                posIndex = game::gScrParserGlob[inst].currentSourcePosCount + opcodeLookup->sourcePosIndex;
+                sourcePosLookup = &game::gScrParserGlob[inst].sourcePosLookup[posIndex];
+                sourcePosLookup->sourcePos = sourcePos;
+                if (sourcePos == -1)
+                {
+                    assert(game::gScrParserGlob[inst].delayedSourceIndex == -1);
+
+                    assert(type & game::SOURCE_TYPE_BREAKPOINT);
+
+                    game::gScrParserGlob[inst].delayedSourceIndex = posIndex;
+                }
+                else if (sourcePos == -2)
+                {
+                    game::gScrParserGlob[inst].threadStartSourceIndex = posIndex;
+                }
+                else
+                {
+                    delayedSourceIndex = game::gScrParserGlob[inst].delayedSourceIndex;
+                    if (delayedSourceIndex >= 0 && (type & 1) != 0)
+                    {
+                        game::gScrParserGlob[inst].sourcePosLookup[delayedSourceIndex].sourcePos = sourcePos;
+                        game::gScrParserGlob[inst].delayedSourceIndex = -1;
+                    }
+                }
+
+                sourcePosLookup->type |= type;
+                opcodeLookup->sourcePosCount = ++game::gScrParserGlob[inst].currentSourcePosCount;
+                ++game::gScrParserGlob[inst].opcodeLookupLen;
+                ++game::gScrParserGlob[inst].sourcePosLookupLen;
+            }
+            else
+            {
+                assert(!game::gScrVarPub[inst].developer_script);
+            }
+        }
+    }
+
+    // Decomp Status: Tested, Completed
+    void RemoveOpcodePos(game::scriptInstance_t inst)
+    {
+        game::OpcodeLookup* opcodeLookup;
+
+        if (game::gScrVarPub[inst].developer)
+        {
+            if (game::gScrCompilePub[inst].developer_statement == 2)
+            {
+                assert(!game::gScrVarPub[inst].developer_script);
+            }
+            else
+            {
+                assert(game::gScrParserGlob[inst].opcodeLookup);
+
+                assert(game::gScrParserGlob[inst].opcodeLookupMaxLen);
+
+                assert(game::gScrParserGlob[inst].sourcePosLookup);
+
+                assert(game::gScrCompilePub[inst].opcodePos);
+
+                assert(game::gScrParserGlob[inst].sourcePosLookupLen);
+
+                --game::gScrParserGlob[inst].sourcePosLookupLen;
+
+                assert(game::gScrParserGlob[inst].opcodeLookupLen);
+
+                --game::gScrParserGlob[inst].opcodeLookupLen;
+
+                assert(game::gScrParserGlob[inst].currentSourcePosCount);
+
+                --game::gScrParserGlob[inst].currentSourcePosCount;
+                opcodeLookup = &game::gScrParserGlob[inst].opcodeLookup[game::gScrParserGlob[inst].opcodeLookupLen];
+
+                assert((char*)game::gScrParserGlob[inst].currentCodePos == game::gScrCompilePub[inst].opcodePos);
+
+                assert(opcodeLookup->sourcePosIndex + game::gScrParserGlob[inst].currentSourcePosCount == game::gScrParserGlob[inst].sourcePosLookupLen);
+
+                assert(opcodeLookup->codePos == (char*)game::gScrParserGlob[inst].currentCodePos);
+
+                if (game::gScrParserGlob[inst].currentSourcePosCount == 1)
+                {
+                    game::gScrParserGlob[inst].currentCodePos = 0;
+                }
+
+                game::gScrParserGlob[inst].opcodeLookup[game::gScrParserGlob[inst].opcodeLookupLen].sourcePosCount = game::gScrParserGlob[inst].currentSourcePosCount;
+            }
+
+        }
+    }
+
+    // Decomp Status: Tested, Completed
+    void AddThreadStartOpcodePos(game::scriptInstance_t inst, unsigned int sourcePos)
+    {
+        game::SourceLookup* sourcePosLookup;
+
+        if (game::gScrVarPub[inst].developer)
+        {
+            if (game::gScrCompilePub[inst].developer_statement == 2)
+            {
+                assert(!game::gScrVarPub[inst].developer_script);
+            }
+            else
+            {
+                assert(game::gScrParserGlob[inst].threadStartSourceIndex >= 0);
+
+                sourcePosLookup = &game::gScrParserGlob[inst].sourcePosLookup[game::gScrParserGlob[inst].threadStartSourceIndex];
+                sourcePosLookup->sourcePos = sourcePos;
+
+                assert(!sourcePosLookup->type);
+
+                sourcePosLookup->type = 4;
+                game::gScrParserGlob[inst].threadStartSourceIndex = -1;
+            }
+        }
+    }
+
+    // Decomp Status: Completed
+    unsigned int Scr_GetSourceBuffer(game::scriptInstance_t inst, const char* codePos)
+    {
+        unsigned int bufferIndex;
+        
+        assert(game::Scr_IsInOpcodeMemory(inst, codePos));
+
+        assert(game::gScrParserPub[inst].sourceBufferLookupLen > 0);
+
+        for ( bufferIndex = game::gScrParserPub[inst].sourceBufferLookupLen - 1;
+            bufferIndex && (!game::gScrParserPub[inst].sourceBufferLookup[bufferIndex].codePos || game::gScrParserPub[inst].sourceBufferLookup[bufferIndex].codePos > codePos);
+            --bufferIndex )
+        {
+            ;
+        }
+
+        return bufferIndex;
+    }
+
+    // Decomp Status: Tested, Completed
+    unsigned int Scr_GetLineNumInternal(const char** startLine, const char* buf, const char* sourcePos, int* col)
+    {
+        unsigned int lineNum;
+
+        assert(buf);
+
+        lineNum = 0;
+        for (*startLine = buf; sourcePos; --sourcePos)
+        {
+            if (!*buf)
+            {
+                *startLine = buf + 1;
+                ++lineNum;
+            }
+            ++buf;
+        }
+        *col = buf - *startLine;
+        return lineNum;
+    }
+
+    // Decomp Status: Tested, Completed
+    game::SourceBufferInfo* Scr_GetNewSourceBuffer(game::scriptInstance_t inst)
+    {
+        unsigned int* sourceBufferLookupMaxLen;
+        int allocSize;
+        game::SourceBufferInfo* newSourceBufferInfo;
+
+        assert(game::gScrParserPub[inst].sourceBufferLookup);
+
+        assert(game::gScrParserGlob[inst].sourceBufferLookupMaxLen);
+
+        if (game::gScrParserPub[inst].sourceBufferLookupLen < game::gScrParserGlob[inst].sourceBufferLookupMaxLen)
+        {
+            return &game::gScrParserPub[inst].sourceBufferLookup[game::gScrParserPub[inst].sourceBufferLookupLen++];
+        }
+
+        //assert(gScrParserPub[inst].sourceBufferLookupLen >= gScrParserGlob[inst].sourceBufferLookupMaxLen);
+
+        sourceBufferLookupMaxLen = &game::gScrParserGlob[inst].sourceBufferLookupMaxLen;
+        allocSize = 2 * *sourceBufferLookupMaxLen;
+        *sourceBufferLookupMaxLen = allocSize;
+        newSourceBufferInfo = (game::SourceBufferInfo*)game::Hunk_UserAlloc((game::HunkUser*)game::g_DebugHunkUser.get(), sizeof(game::OpcodeLookup) * allocSize, 4);
+        memcpy(newSourceBufferInfo, game::gScrParserPub[inst].sourceBufferLookup, sizeof(game::OpcodeLookup) * game::gScrParserPub[inst].sourceBufferLookupLen);
+        game::gScrParserPub[inst].sourceBufferLookup = newSourceBufferInfo;
+        return &game::gScrParserPub[inst].sourceBufferLookup[game::gScrParserPub[inst].sourceBufferLookupLen++];
+    }
+
+    // Decomp Status: Tested, Completed
+    void Scr_AddSourceBufferInternal(const char* filename, game::scriptInstance_t inst, const char* codepos, char* buffer, int len, int archive)
+    {
+        game::SourceBufferInfo* newBuffer;
+        const char* source;
+        char* buf;
+        char c;
+        int i;
+        char* tmp;
+        size_t size;
+        char* dest;
+
+        if (game::gScrParserPub[inst].sourceBufferLookup)
+        {
+            size = strlen(filename);
+            dest = (char*)game::Hunk_UserAlloc((struct game::HunkUser*)game::g_DebugHunkUser.get(), size + len + 3, 4);
+            memcpy(dest, filename, size + 1);
+            if (buffer)
+            {
+                source = &dest[size + 1];
+            }
+            else
+            {
+                source = 0;
+            }
+            buf = buffer;
+            tmp = (char*)source;
+            if (len >= 0)
+            {
+                for (i = 0; i <= len; ++i)
+                {
+                    c = *buf++;
+                    if (c == '\n' || c == '\r' && *buf != '\n')
+                        *tmp = 0;
+                    else
+                        *tmp = c;
+                    ++tmp;
+                }
+            }
+            newBuffer = game::Scr_GetNewSourceBuffer(inst);
+            newBuffer->codePos = codepos;
+            newBuffer->buf = dest;
+            newBuffer->sourceBuf = source;
+            newBuffer->len = len;
+            newBuffer->sortedIndex = -1;
+            newBuffer->archive = archive;
+            if (source)
+            {
+                game::gScrParserPub[inst].sourceBuf = source;
+            }
+        }
+        else
+        {
+            game::gScrParserPub[inst].sourceBuf = 0;
+        }
+    }
+
+    // Decomp Status: Tested, Completed
+    char* Scr_ReadFile_FastFile(game::scriptInstance_t inst, [[maybe_unused]] int unused, char* filename, const char* codepos, int archive)
+    {
+        char* buffer;
+        game::RawFile* scriptFile;
+
+        scriptFile = game::DB_FindXAssetHeader(game::ASSET_TYPE_RAWFILE, filename, 1, -1).rawfile;
+        if ((*game::useFastFile)->current.enabled && scriptFile != 0)
+        {
+            game::Scr_AddSourceBufferInternal(filename, inst, codepos, scriptFile->buffer, strlen(scriptFile->buffer), archive);
+            buffer = scriptFile->buffer;
+        }
+        else
+        {
+            game::Scr_AddSourceBufferInternal(filename, inst, codepos, 0, -1, archive);
+            buffer = 0;
+        }
+        return buffer;
+    }
+
+    // Decomp Status: Tested, Completed
+    char* Scr_ReadFile_LoadObj(game::scriptInstance_t inst, [[maybe_unused]] int unused_arg1, const char* filename, const char* codepos, int archive)
+    {
+        int fileLen;
+        int fh;
+        char* buffer;
+
+        fileLen = game::FS_FOpenFileRead(filename, &fh);
+        if (fh)
+        {
+            game::fsh[fh].fileSize = fileLen;
+            game::fsh[fh].streamed = 0;
+        }
+
+        game::fsh[fh].handleSync = 0;
+        if (fileLen >= 0)
+        {
+            if (!(*game::fs_game)->current.string)
+            {
+                game::Scr_SetLoadedImpureScript(true);
+            }
+            buffer = (char*)game::Hunk_AllocateTempMemoryHigh(fileLen + 1);
+            game::FS_Read(buffer, fileLen, fh);
+            buffer[fileLen] = 0;
+            game::FS_FCloseFile(fh);
+            game::Scr_AddSourceBufferInternal(filename, inst, codepos, buffer, fileLen, archive);
+        }
+        else
+        {
+            game::Scr_AddSourceBufferInternal(filename, inst, codepos, 0, -1, archive);
+            buffer = 0;
+        }
+
+        return buffer;
+    }
+
+    // Decomp Status: Tested, Completed
+    char* Scr_ReadFile(const char* codepos, char* filename, game::scriptInstance_t inst, int unused)
+    {
+        char* buffer;
+        int fh;
+
+        if (*(*game::fs_game)->current.string || (*game::com_developer)->current.enabled)
+        {
+            *game::statmon_related_bool = 1;
+            if (game::FS_FOpenFileByMode(filename, &fh, game::FS_READ) < 0)
+            {
+                buffer = game::Scr_ReadFile_FastFile(inst, unused, filename, codepos, 1);
+            }
+            else
+            {
+                game::FS_FCloseFile(fh);
+                buffer = game::Scr_ReadFile_LoadObj(inst, unused, filename, codepos, 1);
+            }
+        }
+        else
+        {
+            if (!(*game::useFastFile)->current.enabled)
+            {
+                buffer = game::Scr_ReadFile_LoadObj(inst, unused, filename, codepos, 1);
+            }
+            else
+            {
+                buffer = game::Scr_ReadFile_FastFile(inst, unused, filename, codepos, 1);
+            }
+
+        }
+        return buffer;
+    }
+
+    // Decomp Status: Completed
+    char* Scr_AddSourceBuffer(game::scriptInstance_t inst, int unused_arg1, char* filename, const char* codepos)
+    {
+        unsigned int saveSourceBufferLookupLen;
+        int len;
+        game::SaveSourceBufferInfo* saveSourceBuffer;
+        char* dest;
+        char* sourceBuf;
+        char* source;
+        int len2;
+        char c;
+
+        if (!game::gScrParserGlob[inst].saveSourceBufferLookup)
+        {
+            return game::Scr_ReadFile(codepos, filename, inst, unused_arg1);
+        }
+
+        assert(game::gScrParserGlob[inst].saveSourceBufferLookupLen > 0);
+
+        saveSourceBufferLookupLen = --game::gScrParserGlob[inst].saveSourceBufferLookupLen;
+        len = game::gScrParserGlob[inst].saveSourceBufferLookup[saveSourceBufferLookupLen].len;
+        saveSourceBuffer = &game::gScrParserGlob[inst].saveSourceBufferLookup[saveSourceBufferLookupLen];
+
+        assert(len >= -1);
+
+        if (len >= 0)
+        {
+            sourceBuf = (char*)game::Hunk_AllocateTempMemoryHigh(len + 1);
+            source = (char*)saveSourceBuffer->sourceBuf;
+            dest = sourceBuf;
+            if (len > 0)
+            {
+                len2 = len;
+                do
+                {
+                    c = *source++;
+                    if (!c)
+                    {
+                        c = '\n';
+                    }
+                    *dest++ = c;
+                    --len2;
+                } while (len2);
+            }
+            *dest = 0;
+        }
+        else
+        {
+            dest = 0;
+        }
+
+        game::Scr_AddSourceBufferInternal(filename, inst, codepos, dest, len, 1);
+        return dest;
+    }
+
+    // Decomp Status: Completed
+    void Scr_CopyFormattedLine(const char* rawLine, char* line)
+    {
+        char cleanChar;
+        int len;
+        int i;
+
+        len = strlen(rawLine);
+        if ( len >= 1024 )
+        {
+            len = 1023;
+        }
+
+        for ( i = 0;
+            i < len;
+            ++i )
+        {
+            if ( rawLine[i] == '\t' )
+            {
+                cleanChar = ' ';
+            }
+            else
+            {
+                cleanChar = rawLine[i];
+            }
+
+            line[i] = cleanChar;
+        }
+
+        if ( line[len - 1] == '\r' )
+        {
+            line[len - 1] = 0;
+        }
+
+        line[len] = 0;
+    }
+
+    // Decomp Status: Completed
+    unsigned int Scr_GetLineInfo(int* col, const char* buf, unsigned int sourcePos, char* line)
+    {
+        const char *startLine;
+        unsigned int lineNum;
+
+        if ( buf )
+        {
+            lineNum = game::Scr_GetLineNumInternal(&startLine, buf, (const char*)sourcePos, col);
+        }
+        else
+        {
+            lineNum = 0;
+            startLine = "";
+            *col = 0;
+        }
+
+        game::Scr_CopyFormattedLine(startLine, line);
+        return lineNum;
+    }
+
+    // Decomp Status: Completed
+    void Scr_PrintSourcePos(unsigned int sourcePos, const char* buf, game::con_channel_e channel, game::scriptInstance_t inst, const char* file)
+    {
+        const char *fileVaLine;
+        const char *lineStr;
+        const char *savegameStr;
+        unsigned int lineNum;
+        char line[1024];
+        int i;
+        int col;
+
+        assert(file);
+
+        lineNum = game::Scr_GetLineInfo(&col, buf, sourcePos, line);
+
+        if ( game::gScrParserGlob[inst].saveSourceBufferLookup )
+        {
+            savegameStr = " (savegame)";
+        }
+        else
+        {
+            savegameStr = "";
+        }
+
+        fileVaLine = game::va("(file '%s'%s, line %d)\n", file, savegameStr, lineNum + 1);
+        game::Com_PrintMessage(channel, fileVaLine, 0);
+
+        lineStr = game::va("%s\n", line);
+        game::Com_PrintMessage(channel, lineStr, 0);
+
+        for ( i = 0;
+            i < col;
+            ++i )
+        {
+            game::Com_PrintMessage(channel, " ", 0);
+        }
+
+        game::Com_PrintMessage(channel, "*\n", 0);
+    }
+
+    // Decomp Status: Completed
+    game::OpcodeLookup* Scr_GetPrevSourcePosOpcodeLookup(game::scriptInstance_t inst, const char* codePos)
+    {
+        unsigned int low;
+        unsigned int middle;
+        unsigned int high;
+
+        assert(game::Scr_IsInOpcodeMemory(inst, codePos));
+
+        assert(game::gScrParserGlob[inst].opcodeLookup);
+
+        low = 0;
+        high = game::gScrParserGlob[inst].opcodeLookupLen - 1;
+        while ( low <= high )
+        {
+            middle = (high + low) >> 1;
+            if ( codePos < game::gScrParserGlob[inst].opcodeLookup[middle].codePos )
+            {
+                high = middle - 1;
+            }
+            else
+            {
+                low = middle + 1;
+                if ( middle + 1 == game::gScrParserGlob[inst].opcodeLookupLen || codePos < game::gScrParserGlob[inst].opcodeLookup[low].codePos )
+                {
+                    return &game::gScrParserGlob[inst].opcodeLookup[middle];
+                }
+            }
+        }
+
+        assert(false);
+
+        return 0;
+    }
+
+    // Restored
+    unsigned int Scr_GetPrevSourcePos(game::scriptInstance_t inst, const char *codePos, unsigned int index)
+    {
+        return game::gScrParserGlob[inst].sourcePosLookup[index + game::Scr_GetPrevSourcePosOpcodeLookup(inst, codePos)->sourcePosIndex].sourcePos;
+    }
+
+    // Decomp Status: Completed
+    void Scr_GetTextSourcePos(char* line, const char* codePos, game::scriptInstance_t inst)
+    {
+        unsigned int prevsourcePos;
+        unsigned int bufferIndex;
+        int col;
+
+        if ( game::gScrVarPub[inst].developer
+            && codePos
+            && codePos != game::g_EndPos.get()
+            && game::gScrVarPub[inst].programBuffer
+            && game::Scr_IsInOpcodeMemory(inst, codePos) )
+        {
+            bufferIndex = game::Scr_GetSourceBuffer(inst, codePos - 1);
+            prevsourcePos = game::Scr_GetPrevSourcePos(inst, codePos - 1, 0);
+            game::Scr_GetLineInfo(&col, game::gScrParserPub[inst].sourceBufferLookup[bufferIndex].sourceBuf, prevsourcePos, line);
+        }
+        else
+        {
+            *line = 0;
+        }
+    }
+
+    // Decomp Status: Completed
+    void Scr_PrintPrevCodePos(const char* codepos, game::scriptInstance_t scriptInstance, game::con_channel_e channel, unsigned int index)
+    {
+        unsigned int bufferIndex; // esi
+        unsigned int prevSourcepos; // eax
+
+        if (!codepos)
+        {
+            game::Com_PrintMessage(channel, "<frozen thread>\n", 0);
+            return;
+        }
+
+        if (codepos == game::g_EndPos.get())
+        {
+            game::Com_PrintMessage(channel, "<removed thread>\n", 0);
+        }
+        else
+        {
+            if (game::gScrVarPub[scriptInstance].developer)
+            {
+                if (game::gScrVarPub[scriptInstance].programBuffer && game::Scr_IsInOpcodeMemory(scriptInstance, codepos)) 
+                {
+                    bufferIndex = game::Scr_GetSourceBuffer(scriptInstance, codepos - 1);
+                    prevSourcepos = game::Scr_GetPrevSourcePos(scriptInstance, codepos - 1, index);
+
+                    game::Scr_PrintSourcePos(
+                        prevSourcepos,
+                        game::gScrParserPub[scriptInstance].sourceBufferLookup[bufferIndex].sourceBuf,
+                        channel,
+                        scriptInstance,
+                        game::gScrParserPub[scriptInstance].sourceBufferLookup[bufferIndex].buf);
+                    return;
+                }
+            }
+            else
+            {
+                if (game::Scr_IsInOpcodeMemory(scriptInstance, codepos - 1))
+                {
+                    game::Com_PrintMessage(channel, game::va("@ %d\n", codepos - game::gScrVarPub[scriptInstance].programBuffer), 0);
+                    return;
+                }
+            }
+
+            game::Com_PrintMessage(channel, game::va("%s\n\n", codepos), 0);
+        }
+    }
+
+    // Restored
+    void Scr_ShutdownAllocNode(game::scriptInstance_t inst)
+    {
+        if (game::g_allocNodeUser[inst])
+        {
+            game::Hunk_UserDestroy(game::g_allocNodeUser[inst]);
+            game::g_allocNodeUser[inst] = 0;
+        }
+    }
+
+    // Decomp Status: Completed
+    void CompileError(game::scriptInstance_t inst, unsigned int codePos, const char* msg, ...)
+    {
+        const char* instStr;
+        int col;
+        int lineNumber;
+        char text[1024];
+        char line[1024];
+        va_list va;
+
+        va_start(va, msg);
+        vsnprintf(text, 0x400u, msg, va);
+        va_end(va);
+
+        instStr = "Server";
+        if (inst)
+        {
+            instStr = "Client";
+        }
+
+        if (game::gScrVarPub[inst].evaluate)
+        {
+            if (!game::gScrVarPub[inst].error_message)
+            {
+                game::gScrVarPub[inst].error_message = (char*)game::va("%s", text);
+            }
+        }
+        else
+        {
+            game::Scr_ShutdownAllocNode(inst);
+
+            game::Com_PrintError(game::CON_CHANNEL_PARSERSCRIPT, "\n");
+            game::Com_PrintError(game::CON_CHANNEL_PARSERSCRIPT, "******* %s script compile error *******\n", instStr);
+
+            if (game::gScrVarPub[inst].developer && game::gScrParserPub[inst].sourceBuf)
+            {
+                game::Com_PrintError(game::CON_CHANNEL_PARSERSCRIPT, "%s: ", text);
+                game::Scr_PrintSourcePos(
+                    codePos,
+                    game::gScrParserPub[inst].sourceBuf,
+                    game::CON_CHANNEL_PARSERSCRIPT,
+                    inst,
+                    game::gScrParserPub[inst].scriptfilename);
+                lineNumber = game::Scr_GetLineInfo(&col, game::gScrParserPub[inst].sourceBuf, codePos, line);
+            }
+            else
+            {
+                game::Com_PrintError(game::CON_CHANNEL_PARSERSCRIPT, "%s\n", text);
+                line[0] = 0;
+                lineNumber = 0;
+            }
+            game::Com_Printf(game::CON_CHANNEL_PARSERSCRIPT, "************************************\n");
+            game::Com_Error(game::ERR_SCRIPT_DROP, "\x15" "%s script compile error\n%s\n%s\n(see console for details)\n", instStr, text, line);
+        }
+    }
+
+    // Decomp Status: Completed
+    void CompileError2(const char* codePos, game::scriptInstance_t inst, const char* msg, ...)
+    {
+        const char* instStr;
+        char text[1024];
+        char line[1024];
+        va_list va;
+
+        va_start(va, msg);
+
+        assert(!game::gScrVarPub[inst].evaluate);
+
+        assert(game::Scr_IsInOpcodeMemory(inst, codePos));
+
+        vsnprintf(text, 0x400u, msg, va);
+        va_end(va);
+
+        instStr = "Server";
+        if (inst)
+        {
+            instStr = "Client";
+        }
+
+        game::Com_PrintError(game::CON_CHANNEL_PARSERSCRIPT, "\n");
+        game::Com_PrintError(game::CON_CHANNEL_PARSERSCRIPT, "******* %s script compile error *******\n", instStr);
+        game::Com_PrintError(game::CON_CHANNEL_PARSERSCRIPT, "%s: ", text);
+        game::Scr_PrintPrevCodePos(codePos, inst, game::CON_CHANNEL_PARSERSCRIPT, 0);
+        game::Com_Printf(game::CON_CHANNEL_PARSERSCRIPT, "************************************\n");
+        game::Scr_GetTextSourcePos(line, codePos, inst);
+        game::Com_Error(game::ERR_SCRIPT_DROP, "\x15" "%s script compile error\n%s\n%s\n(see console for details)\n", instStr, text, line);
+    }
+
+    // Decomp Status: Completed
+    void RuntimeErrorInternal(const char* msg, game::scriptInstance_t inst, game::con_channel_e channel, const char* codepos, int index)
+    {
+        int functionCount;
+        int i;
+
+        assert(game::Scr_IsInOpcodeMemory(inst, codepos));
+
+        game::Com_PrintError(channel, "\n******* script runtime error *******\n%s: ", msg);
+        game::Scr_PrintPrevCodePos(codepos, inst, channel, index);
+        functionCount = game::gScrVmPub[inst].function_count;
+        if (functionCount)
+        {
+            for (i = game::gScrVmPub[inst].function_count - 1;
+                i >= 1;
+                --i)
+            {
+                game::Com_PrintError(channel, "called from:\n");
+                game::Scr_PrintPrevCodePos(game::gScrVmPub[inst].function_frame_start[i].fs.pos, inst, game::CON_CHANNEL_DONT_FILTER, game::gScrVmPub[inst].function_frame_start[i].fs.localId == 0);
+            }
+
+            game::Com_PrintError(channel, "started from:\n");
+            game::Scr_PrintPrevCodePos(game::gScrVmPub[inst].function_frame_start[0].fs.pos, inst, game::CON_CHANNEL_DONT_FILTER, 1u);
+        }
+        game::Com_PrintError(channel, "************************************\n");
+    }
+
+    // Decomp Status: Completed
+    void RuntimeError(game::scriptInstance_t inst, const char* codePos, int index, const char* msg, const char* dialogMessage)
+    {
+        bool abort_or_terminal;
+        const char* errNewline;
+        const char* errNewline2;
+
+        if (!game::gScrVarPub[inst].developer)
+        {
+            assert(game::Scr_IsInOpcodeMemory(inst, codePos));
+
+            if (!game::gScrVmPub[inst].terminal_error)
+            {
+                return;
+            }
+        }
+
+        if (game::gScrVmPub[inst].debugCode)
+        {
+            game::Com_Printf(game::CON_CHANNEL_PARSERSCRIPT, "%s\n", msg);
+
+            if (!game::gScrVmPub[inst].terminal_error)
+            {
+                return;
+            }
+        }
+        else
+        {
+            abort_or_terminal = game::gScrVmPub[inst].abort_on_error || game::gScrVmPub[inst].terminal_error;
+            game::RuntimeErrorInternal(
+                msg,
+                inst,
+                abort_or_terminal ? game::CON_CHANNEL_PARSERSCRIPT : game::CON_CHANNEL_LOGFILEONLY,
+                codePos,
+                index);
+
+            if (!abort_or_terminal)
+            {
+                return;
+            }
+        }
+
+        errNewline = dialogMessage;
+        if (dialogMessage)
+        {
+            errNewline2 = "\n";
+        }
+        else
+        {
+            errNewline = "";
+            errNewline2 = "";
+        }
+
+        game::Com_Error(
+            game::gScrVmPub[inst].terminal_error ? game::ERR_FATAL : game::ERR_SCRIPT,
+            "\x15" "script runtime error\n(see console for details)\n%s%s%s",
+            msg,
+            errNewline2,
+            errNewline);
+    }
+}

src/codsrc/clientscript/cscr_parser.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+namespace codsrc
+{
+	void Scr_InitOpcodeLookup(game::scriptInstance_t a1);
+	void Scr_ShutdownOpcodeLookup(game::scriptInstance_t a1);
+	void AddOpcodePos(game::scriptInstance_t a1, unsigned int sourcePos, int type);
+	void RemoveOpcodePos(game::scriptInstance_t result);
+	void AddThreadStartOpcodePos(game::scriptInstance_t result, unsigned int sourcePos);
+	unsigned int Scr_GetSourceBuffer(game::scriptInstance_t a1, const char* codePos);
+	unsigned int Scr_GetLineNumInternal(const char** startLine, const char* buf, const char* sourcePos, int* col);
+	game::SourceBufferInfo* Scr_GetNewSourceBuffer(game::scriptInstance_t a1);
+	void Scr_AddSourceBufferInternal(const char* filename, game::scriptInstance_t inst, const char* codepos, char* buffer, int len, int archive);
+	char* Scr_ReadFile_FastFile(game::scriptInstance_t inst, int unused, char* filename, const char* codepos, int archive);
+	char* Scr_ReadFile_LoadObj(game::scriptInstance_t inst, int unused_arg1, const char* filename, const char* codepos, int archive);
+	char* Scr_ReadFile(const char* codepos, char* filename, game::scriptInstance_t inst, int unused);
+	char* Scr_AddSourceBuffer(game::scriptInstance_t inst, int unused_arg1, char* filename, const char* codepos);
+	void Scr_CopyFormattedLine(const char* rawLine, char* line);
+	unsigned int Scr_GetLineInfo(int* col, const char* buf, unsigned int sourcePos, char* line);
+	void Scr_PrintSourcePos(unsigned int sourcePos, const char* buf, game::con_channel_e channel, game::scriptInstance_t a4, const char* file);
+	game::OpcodeLookup * Scr_GetPrevSourcePosOpcodeLookup(game::scriptInstance_t a1, const char* codePos);
+	void Scr_GetTextSourcePos(char* line, const char* codePos, game::scriptInstance_t a3);
+	void Scr_PrintPrevCodePos(const char* codepos, game::scriptInstance_t scriptInstance, game::con_channel_e channel, unsigned int index);
+	void CompileError(game::scriptInstance_t a1, unsigned int codePos, const char* msg, ...);
+	void CompileError2(const char* codePos, game::scriptInstance_t a2, const char* msg, ...);
+	void RuntimeErrorInternal(const char* msg, game::scriptInstance_t inst, game::con_channel_e channel, const char* codepos, int index);
+	void RuntimeError(game::scriptInstance_t inst, const char* pos, int error_index, const char* err, const char* err2);
+
+	unsigned int Scr_GetPrevSourcePos(game::scriptInstance_t inst, const char* codePos, unsigned int index);
+	void Scr_ShutdownAllocNode(game::scriptInstance_t inst);
+}

src/codsrc/clientscript/cscr_parsetree.cpp

@@ -0,0 +1,191 @@
+#include <stdinc.hpp>
+#include "clientscript_public.hpp"
+
+namespace codsrc
+{
+	// Decomp Status: Tested, Completed
+	void Scr_InitAllocNode(game::scriptInstance_t inst)
+	{
+		game::HunkUser* nodeUser;
+
+		assert(!game::g_allocNodeUser[inst]);
+
+		nodeUser = game::Hunk_UserCreate(0x10000, "Scr_InitAllocNode", false, true, false, 7);
+		game::g_allocNodeUser[inst] = nodeUser;
+	}
+
+	// Restored function
+	game::sval_u* Scr_AllocNode(game::scriptInstance_t inst, int size)
+	{
+		assert(game::g_allocNodeUser[inst]);
+
+		return (game::sval_u*)game::Hunk_UserAlloc(game::g_allocNodeUser[inst], 4 * size, 4);
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u node0()
+	{
+		game::sval_u result;
+
+		result.node = game::Scr_AllocNode(*game::gInst, 1);
+		result.node[0].intValue = game::ENUM_NOP;
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u node1(game::scr_enum_t type, game::sval_u val1)
+	{
+		game::sval_u result;
+
+		result.node = game::Scr_AllocNode(*game::gInst, 2);
+		result.node[0].intValue = type;
+		result.node[1].node = val1.node;
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u node2(game::scr_enum_t type, game::sval_u val1, game::sval_u val2)
+	{
+		game::sval_u result;
+
+		result.node = game::Scr_AllocNode(*game::gInst, 3);
+		result.node[0].intValue = type;
+		result.node[1].node = val1.node;
+		result.node[2].node = val2.node;
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u node3(game::scr_enum_t type, game::sval_u val1, game::sval_u val2, game::sval_u val3)
+	{
+		game::sval_u result;
+
+		result.node = game::Scr_AllocNode(*game::gInst,4);
+		result.node[0].intValue = type;
+		result.node[1].node = val1.node;
+		result.node[2].node = val2.node;
+		result.node[3].node = val3.node;
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u node4(game::scr_enum_t type, game::sval_u val1, game::sval_u val2, game::sval_u val3, game::sval_u val4)
+	{
+		game::sval_u result;
+
+		result.node = game::Scr_AllocNode(*game::gInst, 5);
+		result.node[0].intValue = type;
+		result.node[1].node = val1.node;
+		result.node[2].node = val2.node;
+		result.node[3].node = val3.node;
+		result.node[4].node = val4.node;
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u node5(game::scr_enum_t type, game::sval_u val1, game::sval_u val2, game::sval_u val3, game::sval_u val4, game::sval_u val5)
+	{
+		game::sval_u result;
+
+		result.node = game::Scr_AllocNode(*game::gInst, 6);
+		result.node[0].intValue = type;
+		result.node[1].node = val1.node;
+		result.node[2].node = val2.node;
+		result.node[3].node = val3.node;
+		result.node[4].node = val4.node;
+		result.node[5].node = val5.node;
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u node6(game::sval_u val1, game::sval_u val2, game::sval_u val3, game::sval_u val4, game::sval_u val5, game::sval_u val6)
+	{
+		game::sval_u result;
+
+		result.node = game::Scr_AllocNode(*game::gInst, 7);
+		result.node[0].intValue = game::ENUM_thread;
+		result.node[1].node = val1.node;
+		result.node[2].node = val2.node;
+		result.node[3].node = val3.node;
+		result.node[4].node = val4.node;
+		result.node[5].node = val5.node;
+		result.node[6].node = val6.node;
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u node7(game::sval_u val1, game::sval_u val2, game::sval_u val3, game::sval_u val4, game::sval_u val5, game::sval_u val6, game::sval_u val7)
+	{
+		game::sval_u result;
+
+		result.node = game::Scr_AllocNode(*game::gInst, 8);
+		result.node[0].intValue = game::ENUM_if_else;
+		result.node[1].node = val1.node;
+		result.node[2].node = val2.node;
+		result.node[3].node = val3.node;
+		result.node[4].node = val4.node;
+		result.node[5].node = val5.node;
+		result.node[6].node = val6.node;
+		result.node[7].node = val7.node;
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u node8(game::sval_u val1, game::sval_u val2, game::sval_u val3, game::sval_u val4, game::sval_u val5, game::sval_u val6, game::sval_u val7, game::sval_u val8)
+	{
+		game::sval_u result;
+
+		result.node = game::Scr_AllocNode(*game::gInst, 9);
+		result.node[0].intValue = game::ENUM_for;
+		result.node[1].node = val1.node;
+		result.node[2].node = val2.node;
+		result.node[3].node = val3.node;
+		result.node[4].node = val4.node;
+		result.node[5].node = val5.node;
+		result.node[6].node = val6.node;
+		result.node[7].node = val7.node;
+		result.node[8].node = val8.node;
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u linked_list_end(game::sval_u val1)
+	{
+		game::sval_u* node;
+		game::sval_u result;
+
+		node = game::Scr_AllocNode(*game::gInst, 2);
+		node[0].node = val1.node;
+		node[1].stringValue = 0;
+		result.node = game::Scr_AllocNode(*game::gInst, 2);
+		result.node[0].node = node;
+		result.node[1].node = node;
+		return result;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u prepend_node(game::sval_u val1, game::sval_u val2)
+	{
+		game::sval_u* node;
+
+		node = game::Scr_AllocNode(*game::gInst, 2);
+		node[0] = val1;
+		node[1] = *val2.node;
+		val2.node->node = node;
+		return val2;
+	}
+
+	// Decomp Status: Tested, Completed
+	game::sval_u append_node(game::sval_u val1, game::sval_u val2)
+	{
+		game::sval_u* node;
+
+		node = game::Scr_AllocNode(*game::gInst, 2);
+		node[0] = val2;
+		node[1].stringValue = 0;
+		val1.node[1].node[1].stringValue = (unsigned int)node;
+		val1.node[1].node = node;
+		return val1;
+	}
+
+}

src/codsrc/clientscript/cscr_parsetree.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+namespace codsrc
+{
+	void Scr_InitAllocNode(game::scriptInstance_t inst);
+	game::sval_u* Scr_AllocNode(game::scriptInstance_t inst, int size);
+	game::sval_u node0();
+	game::sval_u node1(game::scr_enum_t type, game::sval_u val1);
+	game::sval_u node2(game::scr_enum_t type, game::sval_u val1, game::sval_u val2);
+	game::sval_u node3(game::scr_enum_t type, game::sval_u val1, game::sval_u val2, game::sval_u val3);
+	game::sval_u node4(game::scr_enum_t type, game::sval_u val1, game::sval_u val2, game::sval_u val3, game::sval_u val4);
+	game::sval_u node5(game::scr_enum_t type, game::sval_u val1, game::sval_u val2, game::sval_u val3, game::sval_u val4, game::sval_u val5);
+	game::sval_u node6(game::sval_u val1, game::sval_u val2, game::sval_u val3, game::sval_u val4, game::sval_u val5, game::sval_u val6);
+	game::sval_u node7(game::sval_u val1, game::sval_u val2, game::sval_u val3, game::sval_u val4, game::sval_u val5, game::sval_u val6, game::sval_u val7);
+	game::sval_u node8(game::sval_u val1, game::sval_u val2, game::sval_u val3, game::sval_u val4, game::sval_u val5, game::sval_u val6, game::sval_u val7, game::sval_u val8);
+	game::sval_u linked_list_end(game::sval_u val1);
+	game::sval_u prepend_node(game::sval_u val1, game::sval_u val2);
+	game::sval_u append_node(game::sval_u val1, game::sval_u val2);
+}

src/codsrc/clientscript/cscr_readwrite.cpp

@@ -0,0 +1,117 @@
+#include <stdinc.hpp>
+#include "clientscript_public.hpp"
+
+namespace codsrc
+{
+	// Restored
+	unsigned int FindVariableIndexInternal(game::scriptInstance_t inst, unsigned int parentId, unsigned int name)
+	{
+		game::VariableValueInternal* parentValue;
+
+		assert(parentId);
+
+		parentValue = &game::gScrVarGlob[inst].parentVariables[parentId + 1];
+
+		assert((parentValue->w.status & VAR_STAT_MASK) == VAR_STAT_EXTERNAL);
+
+		assert((parentValue->w.status & VAR_STAT_MASK) != VAR_STAT_FREE);
+
+		assert(IsObject(parentValue));
+
+		return game::FindVariableIndexInternal2(inst, name, (parentId + name) % 0xFFFD + 1);
+	}
+
+    // Decomp Status: Tested, Completed
+    unsigned int FindVariableIndexInternal2(game::scriptInstance_t inst, unsigned int name, unsigned int index)
+    {
+		unsigned int newIndex;
+		game::VariableValueInternal* newEntryValue;
+		game::VariableValueInternal* entryValue;
+		game::Variable* entry;
+
+		entry = &game::gScrVarGlob[inst].childVariables[index].hash;
+
+		entryValue = &game::gScrVarGlob[inst].childVariables[entry->id];
+
+		assert((name & VAR_NAME_LOW_MASK) == 0);
+
+		assert(index < VARIABLELIST_CHILD_SIZE);
+
+		assert(entry->id < VARIABLELIST_CHILD_SIZE);
+
+		if ((entryValue->w.status & VAR_STAT_MASK) != VAR_STAT_HEAD)
+		{
+			return 0;
+		}
+
+		assert((entryValue->w.status & VAR_STAT_MASK) != VAR_STAT_FREE);
+
+		assert(!IsObject(entryValue));
+
+		if (entryValue->w.status >> VAR_NAME_BIT_SHIFT == name)
+		{
+			return index;
+		}
+
+		newIndex = entryValue->v.next;
+
+		for (entryValue = &game::gScrVarGlob[inst].childVariables[newIndex];
+			entryValue != &game::gScrVarGlob[inst].childVariables[index];
+			entryValue = &game::gScrVarGlob[inst].childVariables[newIndex])
+		{
+			newEntryValue = &game::gScrVarGlob[inst].childVariables[entryValue->hash.id];
+
+			assert((newEntryValue->w.status & VAR_STAT_MASK) == VAR_STAT_MOVABLE);
+
+			assert((newEntryValue->w.status & VAR_STAT_MASK) != VAR_STAT_FREE);
+
+			assert(!IsObject(newEntryValue));
+
+			if (newEntryValue->w.status >> VAR_NAME_BIT_SHIFT == name)
+			{
+				return newIndex;
+			}
+
+			newIndex = newEntryValue->v.next;
+		}
+
+		return 0;
+    }
+
+    // Decomp Status: Tested, Completed
+    unsigned int FindLastSibling(unsigned int parentId, game::scriptInstance_t inst)
+    {
+		game::VariableValueInternal* parentValue;
+		unsigned int nextParentVarIndex;
+		unsigned int id;
+		unsigned int childVarName;
+		unsigned int index;
+
+		assert(parentId);
+
+		parentValue = &game::gScrVarGlob[inst].parentVariables[parentId + 1];
+
+		assert((parentValue->w.status & VAR_STAT_MASK) != VAR_STAT_FREE);
+
+		assert(IsObject(parentValue));
+
+		assert(((parentValue->w.status & VAR_STAT_MASK) == VAR_STAT_EXTERNAL));
+
+		nextParentVarIndex = parentValue->v.next + 1;
+
+		id = game::gScrVarGlob[inst].parentVariables[nextParentVarIndex].hash.u.prev;
+
+        if (!id)
+        {
+            return 0;
+        }
+
+		childVarName = game::gScrVarGlob[inst].childVariables[id].w.status >> VAR_NAME_BIT_SHIFT;
+
+		index = game::FindVariableIndexInternal(inst, parentId, childVarName);
+
+		assert(index);
+
+		return index;
+    }
+}

src/codsrc/clientscript/cscr_readwrite.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace codsrc
+{
+	unsigned int FindVariableIndexInternal2(game::scriptInstance_t inst, unsigned int name, unsigned int index);
+	unsigned int FindLastSibling(unsigned int parentId, game::scriptInstance_t inst);
+	unsigned int FindVariableIndexInternal(game::scriptInstance_t inst, unsigned int parentId, unsigned int name);
+}

src/codsrc/clientscript/cscr_stringlist.cpp

@@ -0,0 +1,821 @@
+#include <stdinc.hpp>
+#include "clientscript_public.hpp"
+
+namespace codsrc
+{
+    // Restored
+    game::RefString* GetRefString(game::scriptInstance_t inst, unsigned int id)
+    {
+        assert(id);
+
+        assert((id * MT_NODE_SIZE) < MT_SIZE);
+
+        return (game::RefString*)&game::gScrMemTreePub[inst].mt_buffer->nodes[id];
+    }
+
+    // Restored
+    game::RefString * GetRefString_0([[maybe_unused]] game::scriptInstance_t inst, const char *str)
+    {
+        assert(str >= (char*)game::gScrMemTreePub[inst].mt_buffer && str < (char*)(game::gScrMemTreePub[inst].mt_buffer + MT_SIZE));
+
+        return (game::RefString *)(str - 4);
+    }
+
+    // Restored
+    int SL_ConvertFromRefString(game::scriptInstance_t inst, game::RefString *refString)
+    {
+        return ((char *)refString - (char *)game::gScrMemTreePub[inst].mt_buffer) / MT_NODE_SIZE;
+    }
+
+    // Restored
+    int SL_ConvertFromString(game::scriptInstance_t inst, const char *str)
+    {
+        game::RefString *v2;
+
+        assert(str);
+
+        v2 = game::GetRefString_0(inst, str);
+        return game::SL_ConvertFromRefString(inst, v2);
+    }
+
+    // Restored
+    const char* SL_ConvertToStringSafe(unsigned int id, game::scriptInstance_t inst)
+    {
+        if (!id)
+        {
+            return "(NULL)";
+        }
+
+        return game::GetRefString(inst, id)->str;
+    }
+
+    // Decomp Status: Completed
+    char* SL_ConvertToString(unsigned int id, game::scriptInstance_t inst)
+    {
+        //assert((!id || !game::gScrStringDebugGlob[inst] || game::gScrStringDebugGlob[inst]->refCount[id]));
+
+        if (!id)
+        {
+            return nullptr;
+        }
+
+        return game::GetRefString(inst, id)->str;
+    }
+
+    // Restored
+    int SL_GetRefStringLen(game::RefString* refString)
+    {
+        int len;
+
+        for ( len = refString->u.s.byteLen - 1;
+            refString->str[len];
+            len += 256 )
+        {
+            ;
+        }
+
+        return len;
+    }
+
+    // Decomp Status: Completed
+    int SL_GetStringLen(unsigned int stringValue, game::scriptInstance_t inst)
+    {
+        game::RefString *refString;
+
+        assert(stringValue);
+
+        refString = game::GetRefString(inst, stringValue);
+
+        return game::SL_GetRefStringLen(refString);
+    }
+
+    // Decomp Status: Completed
+    unsigned int GetHashCode(unsigned int len, const char* str)
+    {
+        unsigned int i;
+
+        if (len >= 0x100)
+        {
+            return (len >> 2) % 0x61A7 + 1;
+        }
+        for (i = 0; len; --len)
+        {
+            i = 31 * i + *str++;
+        }
+        return i % 0x61A7 + 1;
+    }
+
+    // Decomp Status: Completed
+    void SL_Init(game::scriptInstance_t inst)
+    {
+        unsigned int hash;
+        game::HashEntry *entry;
+        unsigned int prev;
+
+        assert(!game::gScrStringGlob[inst].inited);
+
+        game::MT_Init(inst);
+        game::Sys_EnterCriticalSection(game::CRITSECT_SCRIPT_STRING);
+
+        game::gScrStringGlob[inst].hashTable[0].status_next = 0;
+
+        prev = 0;
+        for (hash = 1;
+            hash < HASH_MAX_HASHES;
+            ++hash)
+        {
+            assert(!(hash & HASH_STAT_MASK));
+
+            entry = &game::gScrStringGlob[inst].hashTable[hash];
+            entry->status_next = 0;
+            game::gScrStringGlob[inst].hashTable[prev].status_next |= hash;
+            entry->u.prev = prev;
+            prev = hash;
+        }
+
+        assert(!(game::gScrStringGlob[inst].hashTable[prev].status_next));
+
+        game::gScrStringGlob[inst].hashTable[0].u.prev = prev;
+        game::gScrStringGlob[inst].inited = 1;
+        game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+    }
+
+    // Decomp Status: Completed
+    unsigned int SL_FindStringOfSize(game::scriptInstance_t inst, const char* str, unsigned int len)
+    {
+        unsigned int stringValue;
+        game::HashEntry *entry;
+        int hash;
+        unsigned int newIndex;
+        game::RefString *refStr;
+        game::RefString *refStra;
+        unsigned int prev;
+        game::HashEntry *newEntry;
+
+        assert(str);
+
+        hash = game::GetHashCode(len, str);
+        game::Sys_EnterCriticalSection(game::CRITSECT_SCRIPT_STRING);
+        entry = &game::gScrStringGlob[inst].hashTable[hash];
+
+        if ( (entry->status_next & HASH_STAT_MASK) != HASH_STAT_HEAD )
+        {
+            game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+            return 0;
+        }
+
+        refStr = game::GetRefString(inst, entry->u.prev);
+        if ( (unsigned char)refStr->u.s.byteLen != (unsigned char)len || memcmp(refStr->str, str, len) )
+        {
+            prev = hash;
+            newIndex = (unsigned short)entry->status_next;
+
+            for ( newEntry = &game::gScrStringGlob[inst].hashTable[newIndex];
+                newEntry != entry;
+                newEntry = &game::gScrStringGlob[inst].hashTable[newIndex] )
+            {
+                assert((newEntry->status_next & HASH_STAT_MASK) == HASH_STAT_MOVABLE);
+
+                refStra = game::GetRefString(inst, newEntry->u.prev);
+
+                if ( (unsigned char)refStra->u.s.byteLen == (unsigned char)len && !memcmp(refStra->str, str, len) )
+                {
+                    game::gScrStringGlob[inst].hashTable[prev].status_next = (unsigned short)newEntry->status_next | game::gScrStringGlob[inst].hashTable[prev].status_next & HASH_STAT_MASK;
+                    newEntry->status_next = (unsigned short)entry->status_next | newEntry->status_next & HASH_STAT_MASK;
+                    entry->status_next = newIndex | entry->status_next & HASH_STAT_MASK;
+                    stringValue = newEntry->u.prev;
+                    newEntry->u.prev = entry->u.prev;
+                    entry->u.prev = stringValue;
+
+                    assert((newEntry->status_next & HASH_STAT_MASK) != HASH_STAT_FREE);
+
+                    assert((entry->status_next & HASH_STAT_MASK) != HASH_STAT_FREE);
+
+                    assert(refStra->str == game::SL_ConvertToString(stringValue, inst));
+
+                    game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+                    return stringValue;
+                }
+
+                prev = newIndex;
+                newIndex = (unsigned short)newEntry->status_next;
+            }
+
+            game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+            return 0;
+        }
+
+        assert((entry->status_next & HASH_STAT_MASK) != HASH_STAT_FREE);
+
+        stringValue = entry->u.prev;
+
+        assert(refStr->str == game::SL_ConvertToString(stringValue, inst));
+
+        game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+        return stringValue;
+    }
+
+    // Decomp Status: Completed
+    unsigned int SL_FindString(const char* str, game::scriptInstance_t inst)
+    {
+        return game::SL_FindStringOfSize(inst, str, strlen(str) + 1);
+    }
+
+    // Decomp Status: Completed
+    unsigned int SL_FindLowercaseString(const char* str, game::scriptInstance_t inst)
+    {
+        char stra[8196];
+        unsigned int len;
+        int i;
+
+        len = strlen(str) + 1;
+
+        if ( (int)len > 0x2000 )
+            return 0;
+
+        for ( i = 0;
+            i < (int)len;
+            ++i )
+        {
+            stra[i] = (char)tolower(str[i]);
+        }
+
+        return game::SL_FindStringOfSize(inst, stra, len);
+    }
+
+    // Decomp Status: Completed
+    void SL_AddUserInternal(unsigned int user, game::RefString* refStr)
+    {
+        unsigned __int32 data;
+
+        if ( ((unsigned __int8)user & (unsigned __int8)refStr->u.s.user) == 0 )
+        {
+            do
+                data = refStr->u.data;
+            while ( InterlockedCompareExchange((volatile unsigned int*)&refStr->u.data, data | (user << 16), data) != data);
+
+            InterlockedExchangeAdd((volatile unsigned int*)&refStr->u.data, 1u);
+        }
+    }
+
+    // Restored
+    void SL_AddUser(unsigned int stringValue, unsigned int user, game::scriptInstance_t inst)
+    {
+        game::RefString *refStr;
+
+        refStr = game::GetRefString(inst, stringValue);
+        game::SL_AddUserInternal(user, refStr);
+    }
+
+    // Decomp Status: Untested unknown how to test, completed
+    void Mark_ScriptStringCustom(unsigned int var)
+    {
+        game::SL_AddUser(var, 4u, game::SCRIPTINSTANCE_SERVER);
+    }
+
+    // Decomp Status: Completed
+    unsigned int SL_GetStringOfSize(game::scriptInstance_t inst, const char* str, unsigned int user, unsigned int len)
+    {
+        unsigned int stringValue;
+        game::HashEntry* entry;
+        unsigned int newNext;
+        unsigned int newNexta;
+        int hash;
+        unsigned int newIndex;
+        unsigned int newIndexa;
+        unsigned int newIndexb;
+        game::RefString *refStr;
+        game::RefString *refStra;
+        game::RefString *refStrb;
+        unsigned int nexta;
+        unsigned int next;
+        unsigned int prev;
+        unsigned int prevb;
+        unsigned int preva;
+        game::HashEntry *newEntry;
+        game::HashEntry *newEntrya;
+        game::HashEntry *newEntryb;
+
+        assert(str);
+
+        hash = game::GetHashCode(len, str);
+        game::Sys_EnterCriticalSection(game::CRITSECT_SCRIPT_STRING);
+        entry = &game::gScrStringGlob[inst].hashTable[hash];
+
+        if ( (entry->status_next & HASH_STAT_MASK) == HASH_STAT_HEAD )
+        {
+            refStr = game::GetRefString(inst, entry->u.prev);
+
+            if ( (unsigned char)refStr->u.s.byteLen == (unsigned char)len && !memcmp(refStr->str, str, len) )
+            {
+                game::SL_AddUserInternal(user, refStr);
+
+                assert((entry->status_next & HASH_STAT_MASK) != HASH_STAT_FREE);
+
+                stringValue = entry->u.prev;
+
+                assert(refStr->str == game::SL_ConvertToString(stringValue, inst));
+
+                game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+                return stringValue;
+            }
+
+            prev = hash;
+            newIndex = (unsigned short)entry->status_next;
+            for ( newEntry = &game::gScrStringGlob[inst].hashTable[newIndex];
+                newEntry != entry;
+                newEntry = &game::gScrStringGlob[inst].hashTable[newIndex] )
+            {
+                assert((newEntry->status_next & HASH_STAT_MASK) == HASH_STAT_MOVABLE);
+
+                refStra = game::GetRefString(inst, newEntry->u.prev);
+
+                if ( (unsigned char)refStra->u.s.byteLen == (unsigned char)len && !memcmp(refStra->str, str, len) )
+                {
+                    game::gScrStringGlob[inst].hashTable[prev].status_next = (unsigned short)newEntry->status_next | game::gScrStringGlob[inst].hashTable[prev].status_next & HASH_STAT_MASK;
+                    newEntry->status_next = (unsigned short)entry->status_next | newEntry->status_next & HASH_STAT_MASK;
+                    entry->status_next = newIndex | entry->status_next & HASH_STAT_MASK;
+                    stringValue = newEntry->u.prev;
+                    newEntry->u.prev = entry->u.prev;
+                    entry->u.prev = stringValue;
+                    game::SL_AddUserInternal(user, refStra);
+
+                    assert((newEntry->status_next & HASH_STAT_MASK) != HASH_STAT_FREE);
+
+                    assert((entry->status_next & HASH_STAT_MASK) != HASH_STAT_FREE);
+
+                    assert(refStra->str == game::SL_ConvertToString(stringValue, inst));
+
+                    game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+                    return stringValue;
+                }
+
+                prev = newIndex;
+                newIndex = (unsigned short)newEntry->status_next;
+            }
+
+            newIndexa = game::gScrStringGlob[inst].hashTable->status_next;
+            if ( !newIndexa )
+            {
+                game::Scr_DumpScriptThreads(inst);
+                game::Com_Error(game::ERR_DROP, "\x15" "exceeded maximum number of script strings\n");
+            }
+
+            stringValue = game::MT_AllocIndex(inst, len + 4);
+            newEntrya = &game::gScrStringGlob[inst].hashTable[newIndexa];
+
+            assert((newEntrya->status_next & HASH_STAT_MASK) == HASH_STAT_FREE);
+
+            newNext = (unsigned short)newEntrya->status_next;
+            game::gScrStringGlob[inst].hashTable->status_next = newNext;
+            game::gScrStringGlob[inst].hashTable[newNext].u.prev = 0;
+            newEntrya->status_next = (unsigned short)entry->status_next | HASH_STAT_MOVABLE;
+            entry->status_next = (unsigned short)newIndexa | entry->status_next & HASH_STAT_MASK;
+            newEntrya->u.prev = entry->u.prev;
+        }
+        else
+        {
+            if ( (entry->status_next & HASH_STAT_MASK) != HASH_STAT_FREE )
+            {
+                assert((entry->status_next & HASH_STAT_MASK) == HASH_STAT_MOVABLE);
+
+                next = (unsigned short)entry->status_next;
+                for ( preva = next;
+                    (unsigned short)game::gScrStringGlob[inst].hashTable[preva].status_next != hash;
+                    preva = (unsigned short)game::gScrStringGlob[inst].hashTable[preva].status_next )
+                {
+                    ;
+                }
+
+                assert(preva);
+
+                newIndexb = game::gScrStringGlob[inst].hashTable->status_next;
+                if ( !newIndexb )
+                {
+                    game::Scr_DumpScriptThreads(inst);
+                    game::Com_Error(game::ERR_DROP, "\x15" "exceeded maximum number of script strings\n");
+                }
+
+                stringValue = game::MT_AllocIndex(inst, len + 4);
+                newEntryb = &game::gScrStringGlob[inst].hashTable[newIndexb];
+
+                assert((newEntryb->status_next & HASH_STAT_MASK) == HASH_STAT_FREE);
+
+                newNexta = (unsigned short)newEntryb->status_next;
+                game::gScrStringGlob[inst].hashTable->status_next = newNexta;
+                game::gScrStringGlob[inst].hashTable[newNexta].u.prev = 0;
+                game::gScrStringGlob[inst].hashTable[preva].status_next = newIndexb | game::gScrStringGlob[inst].hashTable[preva].status_next & HASH_STAT_MASK;
+                newEntryb->status_next = next | HASH_STAT_MOVABLE;
+                newEntryb->u.prev = entry->u.prev;
+            }
+            else
+            {
+                stringValue = game::MT_AllocIndex(inst, len + 4);
+                prevb = entry->u.prev;
+                nexta = (unsigned short)entry->status_next;
+                game::gScrStringGlob[inst].hashTable[prevb].status_next = nexta | game::gScrStringGlob[inst].hashTable[prevb].status_next & HASH_STAT_MASK;
+                game::gScrStringGlob[inst].hashTable[nexta].u.prev = prevb;
+            }
+
+            assert((hash & HASH_STAT_MASK) == 0);
+
+            entry->status_next = hash | HASH_STAT_HEAD;
+        }
+
+        assert(stringValue);
+
+        entry->u.prev = stringValue;
+
+        refStrb = game::GetRefString(inst, stringValue);
+        memcpy(refStrb->str, str, len);
+
+        refStrb->u.s.user = user;
+        assert(refStrb->u.s.user == user);
+        refStrb->u.s.refCount = 1;
+        refStrb->u.s.byteLen = len;
+
+        assert((entry->status_next & HASH_STAT_MASK) != HASH_STAT_FREE);
+        assert(refStrb->str == game::SL_ConvertToString(stringValue, inst));
+
+        game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+        return stringValue;
+    }
+
+    // Decomp Status: Untested unknown how to test, Completed
+    unsigned int SL_GetString_(const char* str, game::scriptInstance_t inst, unsigned int user)
+    {
+        return game::SL_GetStringOfSize(inst, str, user, strlen(str) + 1);
+    }
+
+    // Decomp Status: Completed
+    unsigned int SL_GetString__0(const char* str, unsigned int user, game::scriptInstance_t inst)
+    {
+        return game::SL_GetStringOfSize(inst, str, user, strlen(str) + 1);
+    }
+
+    // Decomp Status: Completed
+    unsigned int SL_GetLowercaseStringOfLen(game::scriptInstance_t inst, const char* str, unsigned int user, unsigned int len)
+    {
+        char stra[SL_MAX_STRING_LEN];
+        unsigned int i;
+
+        if (len > SL_MAX_STRING_LEN)
+        {
+            game::Com_Error(game::ERR_DROP, "max string length exceeded: \"%s\"", str);
+        }
+
+        for ( i = 0;
+            i < len;
+            ++i )
+        {
+            stra[i] = (char)tolower(str[i]);
+        }
+
+        return game::SL_GetStringOfSize(inst, stra, user, len);
+    }
+
+    // Decomp Status: Completed
+    unsigned int SL_GetLowercaseString(const char* str)
+    {
+        return game::SL_GetLowercaseStringOfLen(game::SCRIPTINSTANCE_SERVER, str, 0, strlen(str) + 1);
+    }
+
+    // Decomp Status: Completed
+    unsigned int SL_ConvertToLowercase(game::scriptInstance_t inst, unsigned int stringVal, unsigned int user)
+    {
+        char *strCopy;
+        char str[SL_MAX_STRING_LEN];
+        unsigned int answer;
+        unsigned int len;
+        unsigned int i;
+
+        len = game::SL_GetStringLen(stringVal, inst) + 1;
+        if ( len > SL_MAX_STRING_LEN)
+        {
+            return stringVal;
+        }
+
+        strCopy = game::SL_ConvertToString(stringVal, inst);
+
+        for ( i = 0;
+            i < len;
+            ++i )
+        {
+            str[i] = (char)tolower(strCopy[i]);
+        }
+
+        answer = game::SL_GetStringOfSize(inst, str, user, len);
+        game::SL_RemoveRefToString(stringVal, inst);
+        return answer;
+    }
+
+    // Decomp Status: Completed
+    void SL_TransferRefToUser(unsigned int stringValue, unsigned int user, game::scriptInstance_t inst)
+    {
+        unsigned int data;
+        game::RefString *refStr;
+
+        refStr = game::GetRefString(inst, stringValue);
+        if ( ((unsigned char)user & (unsigned char)refStr->u.s.user) != 0 )
+        {
+            InterlockedExchangeAdd((volatile unsigned int*)&refStr->u.data, 0xFFFFFFFF);
+        }
+        else
+        {
+            do
+                data = refStr->u.data;
+            while ( InterlockedCompareExchange((volatile unsigned int*)&refStr->u.data, data | (user << 16), data) != data );
+        }
+    }
+
+    // Decomp Status: Completed
+    void SL_FreeString(game::scriptInstance_t inst, unsigned int stringValue, game::RefString* refStr, unsigned int len)
+    {
+        game::HashEntry *entry;
+        unsigned int newIndex;
+        unsigned int newNext;
+        int index;
+        unsigned int prev;
+        game::HashEntry *newEntry;
+
+        index = game::GetHashCode(len, refStr->str);
+        game::Sys_EnterCriticalSection(game::CRITSECT_SCRIPT_STRING);
+
+        if ( !(unsigned short)refStr->u.s.refCount )
+        {
+            entry = &game::gScrStringGlob[inst].hashTable[index];
+            game::MT_FreeIndex(len + 4, inst, stringValue);
+
+            assert(((entry->status_next & HASH_STAT_MASK) == HASH_STAT_HEAD));
+
+            newIndex = (unsigned short)entry->status_next;
+            newEntry = &game::gScrStringGlob[inst].hashTable[newIndex];
+            if ( entry->u.prev == stringValue )
+            {
+                if ( newEntry == entry )
+                {
+                    newEntry = entry;
+                    newIndex = index;
+                }
+                else
+                {
+                    entry->status_next = (unsigned short)newEntry->status_next | HASH_STAT_HEAD;
+                    entry->u.prev = newEntry->u.prev;
+                    game::gScrStringGlob[inst].nextFreeEntry = entry;
+                }
+            }
+            else
+            {
+                prev = index;
+                while ( 1 )
+                {
+                    assert(newEntry != entry);
+
+                    assert((newEntry->status_next & HASH_STAT_MASK) == HASH_STAT_MOVABLE);
+
+                    if ( newEntry->u.prev == stringValue )
+                    {
+                        break;
+                    }
+
+                    prev = newIndex;
+                    newIndex = (unsigned short)newEntry->status_next;
+                    newEntry = &game::gScrStringGlob[inst].hashTable[newIndex];
+                }
+
+                game::gScrStringGlob[inst].hashTable[prev].status_next = (unsigned short)newEntry->status_next | game::gScrStringGlob[inst].hashTable[prev].status_next & HASH_STAT_MASK;
+            }
+
+            assert((newEntry->status_next & HASH_STAT_MASK) != HASH_STAT_FREE);
+
+            newNext = game::gScrStringGlob[inst].hashTable->status_next;
+
+            assert((newNext & HASH_STAT_MASK) == HASH_STAT_FREE);
+
+            newEntry->status_next = newNext;
+            newEntry->u.prev = 0;
+            game::gScrStringGlob[inst].hashTable[newNext].u.prev = newIndex;
+            game::gScrStringGlob[inst].hashTable->status_next = newIndex;
+        }
+
+        game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+    }
+
+    // Restored
+    void SL_RemoveRefToStringOfSize(game::scriptInstance_t inst, unsigned int stringValue, unsigned int len)
+    {
+        game::RefString *refStr;
+
+        refStr = game::GetRefString(inst, stringValue);
+        if ( !(unsigned __int16)InterlockedDecrement((volatile unsigned int*)&refStr->u.data))
+        {
+            game::SL_FreeString(inst, stringValue, refStr, len);
+        }
+    }
+
+    // Decomp Status: Tested, Completed
+    void SL_RemoveRefToString(unsigned int stringVal, game::scriptInstance_t inst)
+    {
+        game::RefString *refStr;
+        int len;
+
+        refStr = game::GetRefString(inst, stringVal);
+        len = game::SL_GetRefStringLen(refStr) + 1;
+        game::SL_RemoveRefToStringOfSize(inst, stringVal, len);
+    }
+
+    // Restored
+    void SL_AddRefToString(game::scriptInstance_t inst, unsigned int stringValue)
+    {
+        game::RefString* refStr = game::GetRefString(inst, stringValue);
+        InterlockedExchangeAdd((volatile unsigned int*)&refStr->u.data, 1u);
+    }
+
+    // Decomp Status: Tested, Completed
+    void Scr_SetString(game::scriptInstance_t inst, unsigned int from, unsigned __int16* to)
+    {
+        if (from)
+        {
+            game::SL_AddRefToString(inst, from);
+        }
+
+        if (*to)
+        {
+            game::SL_RemoveRefToString(*to, inst);
+        }
+
+        *to = (unsigned short)from;
+    }
+
+    // Decomp Status: Tested, Completed
+    void Scr_SetStringFromCharString(const char* from, unsigned __int16* to)
+    {
+        if (*to)
+        {
+            game::SL_RemoveRefToString(*to, game::SCRIPTINSTANCE_SERVER);
+        }
+
+        *to = (unsigned short)game::SL_GetString_(from, game::SCRIPTINSTANCE_SERVER, 0);
+    }
+
+    // Decomp Status: Tested, Completed
+    unsigned int GScr_AllocString(const char* str, game::scriptInstance_t inst)
+    {
+        return game::SL_GetString_(str, inst, 1);
+    }
+
+    // Decomp Status: Tested, Completed
+    unsigned int SL_GetStringForFloat(float floatVal, game::scriptInstance_t inst)
+    {
+        char Buffer[128];
+
+        sprintf_s(Buffer, "%g", floatVal);
+        return game::SL_GetString_(Buffer, inst, 0);
+    }
+
+    // Decomp Status: Tested, Completed
+    unsigned int SL_GetStringForInt(int intVal, game::scriptInstance_t inst)
+    {
+        char Buffer[128];
+
+        sprintf_s(Buffer, "%i", intVal);
+        return game::SL_GetString_(Buffer, inst, 0);
+    }
+
+    // Decomp Status: Tested, Completed
+    unsigned int SL_GetStringForVector(float* vector, game::scriptInstance_t inst)
+    {
+        char Buffer[128];
+
+        sprintf_s(Buffer, "(%g, %g, %g)", vector[0], vector[1], vector[2]);
+        return game::SL_GetString_(Buffer, inst, 0);
+    }
+
+    // Decomp Status: Tested, Completed
+    void SL_ShutdownSystem(game::scriptInstance_t inst, unsigned int user)
+    {
+        unsigned int hash;
+        game::HashEntry *entry;
+        game::RefString *refStr;
+
+        assert(user);
+
+        game::Sys_EnterCriticalSection(game::CRITSECT_SCRIPT_STRING);
+
+        for ( hash = 1;
+            hash < HASH_MAX_HASHES;
+            ++hash )
+        {
+            do
+            {
+                entry = &game::gScrStringGlob[inst].hashTable[hash];
+                if ( (entry->status_next & HASH_STAT_MASK) == HASH_STAT_FREE )
+                {
+                    break;
+                }
+
+                refStr = game::GetRefString(inst, entry->u.prev);
+                if ( ((unsigned char)user & (unsigned char)refStr->u.s.user) == 0 )
+                {
+                    break;
+                }
+
+                refStr->u.s.user &= ~user;
+                game::gScrStringGlob[inst].nextFreeEntry = 0;
+                game::SL_RemoveRefToString(entry->u.prev, inst);
+            }
+            while ( game::gScrStringGlob[inst].nextFreeEntry );
+        }
+
+        game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+    }
+
+    // Decomp Status: Tested, Completed, Optimized args
+    void SL_TransferSystem()
+    {
+        unsigned int hash;
+        game::HashEntry *entry;
+        game::RefString* refStr;
+
+        // args
+        int from = 4;
+        int to = 8;
+        game::scriptInstance_t inst = game::SCRIPTINSTANCE_SERVER;
+
+        assert(from);
+        assert(to);
+
+        game::Sys_EnterCriticalSection(game::CRITSECT_SCRIPT_STRING);
+
+        for (hash = 1; hash < HASH_MAX_HASHES; hash++)
+        {
+            entry = &game::gScrStringGlob[inst].hashTable[hash];
+
+            if ((entry->status_next & HASH_STAT_MASK) != HASH_STAT_FREE)
+            {
+                refStr = game::GetRefString(inst, entry->u.prev);
+
+                if ( ((unsigned __int8)from & (unsigned __int8)refStr->u.s.user) != 0 )
+                {
+                    refStr->u.s.user &= ~from;
+                    refStr->u.s.user |= to;
+                }
+            }
+        }
+
+        game::Sys_LeaveCriticalSection(game::CRITSECT_SCRIPT_STRING);
+    }
+
+    // Decomp Status: Tested, Completed
+    void SL_CreateCanonicalFilename(const char* filename, char* newFilename)
+    {
+        int count;
+        unsigned int c;
+
+        count = 1024;
+        do
+        {
+            do
+            {
+                do
+                {
+                    c = *filename++;
+                } while (c == '\\');
+            } while (c == '/');
+            if (c >= ' ')
+            {
+                while (1)
+                {
+                    *newFilename++ = (char)tolower(c);
+                    if (!--count)
+                    {
+                        game::Com_Error(game::ERR_DROP, "\x15" "Filename '%s' exceeds maximum length of %d", filename, 0);
+                    }
+                    if (c == '/')
+                    {
+                        break;
+                    }
+                    c = *filename++;
+                    if (c == '\\')
+                    {
+                        c = '/';
+                    }
+                    else if (c < ' ')
+                    {
+                        break;
+                    }
+                }
+            }
+        } while (c);
+        *newFilename = 0;
+    }
+
+    // Decomp Status: Tested, Completed
+    unsigned int Scr_CreateCanonicalFilename(game::scriptInstance_t inst, const char* filename)
+    {
+        char newFileName[1024];
+
+        game::SL_CreateCanonicalFilename(filename, newFileName);
+        return game::SL_GetString_(newFileName, inst, 0);
+    }
+}

src/codsrc/clientscript/cscr_stringlist.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+namespace codsrc
+{
+	char* SL_ConvertToString(unsigned int id, game::scriptInstance_t inst);
+	int SL_GetStringLen(unsigned int a1, game::scriptInstance_t a2);
+	unsigned int GetHashCode(unsigned int a1, const char* a2);
+	void SL_Init(game::scriptInstance_t a1);
+	unsigned int SL_FindStringOfSize(game::scriptInstance_t inst, const char* str, unsigned int len);
+	unsigned int SL_FindString(const char* a1, game::scriptInstance_t a2);
+	unsigned int SL_FindLowercaseString(const char* str, game::scriptInstance_t inst);
+	void SL_AddUserInternal(unsigned int user, game::RefString* refStr);
+	void Mark_ScriptStringCustom(unsigned int a1);
+	unsigned int SL_GetStringOfSize(game::scriptInstance_t inst, const char* string, unsigned int user, unsigned int len);
+	unsigned int SL_GetString_(const char* a1, game::scriptInstance_t a2, unsigned int user);
+	unsigned int SL_GetString__0(const char* a1, unsigned int user, game::scriptInstance_t a3);
+	unsigned int SL_GetLowercaseStringOfLen(game::scriptInstance_t a1, const char* ArgList, unsigned int user, unsigned int len);
+	unsigned int SL_GetLowercaseString(const char* a2);
+	unsigned int SL_ConvertToLowercase(game::scriptInstance_t inst, unsigned int stringVal, unsigned int user);
+	void SL_TransferRefToUser(unsigned int stringValue, unsigned int user, game::scriptInstance_t inst);
+	void SL_FreeString(game::scriptInstance_t inst, unsigned int stringValue, game::RefString* refStr, unsigned int len);
+	void SL_RemoveRefToString(unsigned int stringVal, game::scriptInstance_t inst);
+	void SL_AddRefToString(game::scriptInstance_t inst, unsigned int stringValue);
+	void Scr_SetString(game::scriptInstance_t inst, unsigned int from, unsigned __int16* to);
+	void Scr_SetStringFromCharString(const char* from, unsigned __int16* to);
+	unsigned int GScr_AllocString(const char* a1, game::scriptInstance_t inst);
+	unsigned int SL_GetStringForFloat(float floatVal, game::scriptInstance_t inst);
+	unsigned int SL_GetStringForInt(int intVal, game::scriptInstance_t inst);
+	unsigned int SL_GetStringForVector(float* vector, game::scriptInstance_t inst);
+	void SL_ShutdownSystem(game::scriptInstance_t inst, unsigned int user);
+	void SL_TransferSystem();
+	void SL_CreateCanonicalFilename(const char* filename, char* newFilename);
+	unsigned int Scr_CreateCanonicalFilename(game::scriptInstance_t inst, const char* filename);
+	game::RefString* GetRefString(game::scriptInstance_t inst, unsigned int id);
+	void SL_RemoveRefToStringOfSize(game::scriptInstance_t inst, unsigned int stringValue, unsigned int len);
+	int SL_GetRefStringLen(game::RefString* refString);
+	void SL_AddUser(unsigned int stringValue, unsigned int user, game::scriptInstance_t inst);
+	int SL_ConvertFromString(game::scriptInstance_t inst, const char* str);
+	int SL_ConvertFromRefString(game::scriptInstance_t inst, game::RefString* refString);
+	game::RefString* GetRefString_0(game::scriptInstance_t inst, const char* str);
+	const char* SL_DebugConvertToString(unsigned int stringValue, game::scriptInstance_t inst);
+}

src/codsrc/clientscript/cscr_tempmemory.cpp

@@ -0,0 +1,23 @@
+#include <stdinc.hpp>
+#include "clientscript_public.hpp"
+
+namespace codsrc
+{
+    // Restored
+    char* TempMalloc(int len)
+    {
+        return (char *)game::Hunk_UserAlloc(*game::g_user, len, 1);
+    }
+
+    // Restored
+    void TempMemoryReset(game::HunkUser* user)
+    {
+        *game::g_user = user;
+    }
+
+    // Restored
+    void TempMemorySetPos(char* pos)
+    {
+        (*game::g_user)->pos = (int)pos;
+    }
+}

src/codsrc/clientscript/cscr_tempmemory.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace codsrc
+{
+	char* TempMalloc(int len);
+	void TempMemoryReset(game::HunkUser* user);
+	void TempMemorySetPos(char* pos);
+}

src/codsrc/clientscript/cscr_variable.hpp

@@ -0,0 +1,141 @@
+#pragma once
+
+namespace codsrc
+{
+	int ThreadInfoCompare(const void* a1, const void* a2);
+	void Scr_DumpScriptThreads(game::scriptInstance_t scriptInstance);
+	void Scr_InitVariableRange(unsigned int a1, unsigned int a2, game::scriptInstance_t inst);
+	void Scr_InitClassMap(game::scriptInstance_t inst);
+	unsigned int GetNewVariableIndexInternal3(game::scriptInstance_t inst, unsigned int parentId, unsigned int name, unsigned int index);
+	unsigned int GetNewVariableIndexInternal2(unsigned int name, game::scriptInstance_t inst, unsigned int parentId, unsigned int index);
+	unsigned int GetNewVariableIndexReverseInternal2(unsigned int name, game::scriptInstance_t inst, unsigned int parentId, unsigned int index);
+	void MakeVariableExternal(game::VariableValueInternal* parentValue, game::scriptInstance_t inst, unsigned int index);
+	void FreeChildValue(unsigned int id, game::scriptInstance_t inst, unsigned int parentId);
+	void ClearObjectInternal(game::scriptInstance_t inst, unsigned int parentId);
+	void ClearObject(unsigned int a1, game::scriptInstance_t inst);
+	void Scr_StopThread(game::scriptInstance_t inst, unsigned int a2);
+	unsigned int GetSafeParentLocalId(game::scriptInstance_t inst, unsigned int a2);
+	unsigned int GetStartLocalId(unsigned int result, game::scriptInstance_t inst);
+	void Scr_KillThread(game::scriptInstance_t inst, unsigned int parentId_1);
+	unsigned __int16 AllocVariable(game::scriptInstance_t inst);
+	void FreeVariable(unsigned int a1, game::scriptInstance_t inst);
+	unsigned int AllocValue(game::scriptInstance_t inst);
+	unsigned int AllocEntity(game::classNum_e classnum, game::scriptInstance_t inst, int entnum, int clientnum);
+	unsigned int Scr_AllocArray(game::scriptInstance_t a1);
+	unsigned int AllocChildThread(game::scriptInstance_t inst, unsigned int a2, unsigned int a3);
+	void FreeValue(unsigned int id, game::scriptInstance_t inst);
+	void RemoveRefToObject(unsigned int id, game::scriptInstance_t inst);
+	float* Scr_AllocVector(game::scriptInstance_t a1);
+	void RemoveRefToVector(const float* vectorValue, game::scriptInstance_t inst);
+	void AddRefToValue(game::scriptInstance_t inst, game::VariableType type, game::VariableUnion u);
+	void RemoveRefToValueInternal(game::scriptInstance_t inst, game::VariableType type, game::VariableUnion a3);
+	unsigned int FindArrayVariable(unsigned int id, unsigned int intvalue, game::scriptInstance_t inst);
+	unsigned int FindVariable(unsigned int name, unsigned int a2, game::scriptInstance_t inst);
+	unsigned int GetArrayVariableIndex(unsigned int unsignedValue, game::scriptInstance_t inst, unsigned int parentId);
+	unsigned int Scr_GetVariableFieldIndex(game::scriptInstance_t inst, unsigned int name, unsigned int parentId);
+	game::VariableValue Scr_FindVariableField(game::scriptInstance_t inst, unsigned int parentId, unsigned int name);
+	void ClearVariableField(game::scriptInstance_t inst, unsigned int id, unsigned int name, game::VariableValue* value);
+	unsigned int GetVariable(game::scriptInstance_t inst, unsigned int parentId, unsigned int name);
+	unsigned int GetNewVariable(game::scriptInstance_t inst, unsigned int a2, unsigned int a3);
+	unsigned int GetObjectVariable(unsigned int a1, game::scriptInstance_t inst, unsigned int parentId);
+	unsigned int GetNewObjectVariable(game::scriptInstance_t inst, unsigned int name, unsigned int parentId);
+	void RemoveVariable(unsigned int name, unsigned int parentId, game::scriptInstance_t inst);
+	void RemoveNextVariable(game::scriptInstance_t inst, unsigned int parentId);
+	void SafeRemoveVariable(unsigned int unsignedValue, unsigned int parentId, game::scriptInstance_t inst);
+	void CopyArray(game::scriptInstance_t inst, unsigned int parentId, unsigned int newParentId);
+	void SetVariableValue(game::scriptInstance_t inst, game::VariableValue* a2, unsigned int a3);
+	void SetVariableEntityFieldValue(game::scriptInstance_t inst, unsigned int parentId, unsigned int name, game::VariableValue* a4);
+	game::VariableValue Scr_EvalVariable(game::scriptInstance_t inst, unsigned int a2);
+	unsigned int Scr_EvalVariableObject(game::scriptInstance_t inst, unsigned int a2);
+	game::VariableValue Scr_EvalVariableEntityField(unsigned int entId, game::scriptInstance_t inst, unsigned int name);
+	game::VariableValue Scr_EvalVariableField(game::scriptInstance_t inst, unsigned int id);
+	void Scr_EvalSizeValue(game::scriptInstance_t inst, game::VariableValue* value);
+	unsigned int GetObject(game::scriptInstance_t inst, unsigned int a2);
+	unsigned int GetArray(game::scriptInstance_t inst, unsigned int a2);
+	void Scr_EvalBoolComplement(game::scriptInstance_t inst, game::VariableValue* a2);
+	void Scr_CastBool(game::scriptInstance_t inst, game::VariableValue* a2);
+	char Scr_CastString(game::scriptInstance_t inst, game::VariableValue* a2);
+	void Scr_CastDebugString(game::scriptInstance_t inst, game::VariableValue* a2);
+	void Scr_ClearVector(game::scriptInstance_t inst, game::VariableValue* a2);
+	void Scr_CastVector(game::scriptInstance_t inst, game::VariableValue* a2);
+	game::VariableUnion Scr_EvalFieldObject(game::VariableValue* a1, game::scriptInstance_t inst, unsigned int a3);
+	void Scr_UnmatchingTypesError(game::scriptInstance_t inst, game::VariableValue* a2, game::VariableValue* value);
+	void Scr_CastWeakerPair(game::VariableValue* a1, game::VariableValue* a2, game::scriptInstance_t inst);
+	void Scr_CastWeakerStringPair(game::VariableValue* a1, game::VariableValue* a2, game::scriptInstance_t inst);
+	void Scr_EvalOr(game::VariableValue* result, game::VariableValue* a2, game::scriptInstance_t inst);
+	void Scr_EvalExOr(game::VariableValue* result, game::VariableValue* a2, game::scriptInstance_t inst);
+	void Scr_EvalAnd(game::VariableValue* result, game::VariableValue* a2, game::scriptInstance_t inst);
+	void Scr_EvalEquality(game::VariableValue* a1, game::scriptInstance_t inst, game::VariableValue* a4);
+	void Scr_EvalLess(game::VariableValue* a1, game::VariableValue* a2, game::scriptInstance_t inst);
+	void Scr_EvalGreaterEqual(game::scriptInstance_t inst, game::VariableValue* a2, game::VariableValue* a3);
+	void Scr_EvalGreater(game::VariableValue* a1, game::VariableValue* a2, game::scriptInstance_t inst);
+	void Scr_EvalLessEqual(game::scriptInstance_t inst, game::VariableValue* a2, game::VariableValue* a3);
+	void Scr_EvalShiftLeft(game::VariableValue* result, game::VariableValue* a2, game::scriptInstance_t inst);
+	void Scr_EvalShiftRight(game::VariableValue* result, game::VariableValue* a2, game::scriptInstance_t inst);
+	void Scr_EvalPlus(game::scriptInstance_t inst, game::VariableValue* a1, game::VariableValue* a2);
+	void Scr_EvalMinus(game::VariableValue* a1, game::scriptInstance_t inst, game::VariableValue* a3);
+	void Scr_EvalMultiply(game::VariableValue* a1, game::scriptInstance_t inst, game::VariableValue* a3);
+	void Scr_EvalDivide(game::VariableValue* a1, game::scriptInstance_t inst, game::VariableValue* a3);
+	void Scr_EvalMod(game::scriptInstance_t inst, game::VariableValue* a2, game::VariableValue* a3);
+	void Scr_EvalBinaryOperator(game::scriptInstance_t inst, game::VariableValue* a2, game::OpcodeVM a4, game::VariableValue* a5);
+	void Scr_FreeEntityNum(game::scriptInstance_t inst, game::classNum_e classnum, unsigned int entnum);
+	void Scr_FreeEntityList(game::scriptInstance_t inst);
+	void Scr_FreeObjects(game::scriptInstance_t inst);
+	void Scr_SetClassMap(game::scriptInstance_t inst, game::classNum_e classnum);
+	void Scr_RemoveClassMap(game::classNum_e classnum, game::scriptInstance_t inst);
+	void Scr_AddClassField(game::scriptInstance_t inst, game::classNum_e classnum, const char* name, unsigned int offset);
+	game::VariableUnion Scr_GetOffset(const char* name, game::scriptInstance_t inst, game::classNum_e classNum);
+	unsigned int FindEntityId(unsigned int entClass, int entNum, game::scriptInstance_t inst);
+	unsigned int Scr_GetEntityId(int entNum, game::scriptInstance_t inst, game::classNum_e classnum, int clientnum);
+	unsigned int Scr_FindArrayIndex(game::scriptInstance_t inst, game::VariableValue* a2, unsigned int a3);
+	void Scr_EvalArray(game::scriptInstance_t inst, game::VariableValue* eax0, game::VariableValue* a3);
+	unsigned int Scr_EvalArrayRef(game::scriptInstance_t inst, unsigned int eax0);
+	void ClearArray(unsigned int parentId, game::scriptInstance_t inst, game::VariableValue* value);
+	void SetEmptyArray(game::scriptInstance_t inst, unsigned int parentId);
+	void Scr_AddArrayKeys(unsigned int array, game::scriptInstance_t inst);
+	game::scr_entref_t* Scr_GetEntityIdRef(game::scr_entref_t* result, game::scriptInstance_t inst, unsigned int a3);
+	void CopyEntity(unsigned int parentId, unsigned int newParentId);
+	float Scr_GetEndonUsage(unsigned int a1, game::scriptInstance_t inst);
+	float Scr_GetEntryUsageInternal(game::scriptInstance_t inst, unsigned int type, game::VariableUnion u);
+	float Scr_GetEntryUsage(game::scriptInstance_t inst, game::VariableValueInternal* entryValue);
+	float Scr_GetObjectUsage(game::scriptInstance_t inst, unsigned int parentId);
+	float Scr_GetThreadUsage(game::VariableStackBuffer* inst, game::scriptInstance_t a2, float* endonUsage);
+	unsigned int Scr_FindField(game::scriptInstance_t inst, const char* name, int* type);
+	char* Scr_GetSourceFile_LoadObj(const char* a1);
+	char* Scr_GetSourceFile_FastFile(const char* a3);
+	void Scr_AddFieldsForFile(game::scriptInstance_t inst, const char* filename);
+	void Scr_AddFields_LoadObj(game::scriptInstance_t inst, const char* path, const char* extension);
+	void Scr_AddFields_FastFile(game::scriptInstance_t inst, const char* path, const char* extension);
+	int Scr_MakeValuePrimitive(game::scriptInstance_t inst, unsigned int parentId);
+	void Scr_FreeGameVariable(game::scriptInstance_t inst, int bComplete);
+	bool Scr_SLHasLowercaseString(unsigned int a1, const char* a2);
+
+	unsigned int FindObject(game::scriptInstance_t inst, unsigned int id);
+	unsigned int FindFirstSibling(game::scriptInstance_t inst, unsigned int id);
+	unsigned int FindNextSibling(game::scriptInstance_t inst, unsigned int id);
+	game::VariableValue Scr_GetArrayIndexValue(game::scriptInstance_t inst, unsigned int name);
+	void AddRefToObject(game::scriptInstance_t inst, unsigned int id);
+	void RemoveRefToEmptyObject(game::scriptInstance_t inst, unsigned int id);
+	void Scr_ClearThread(game::scriptInstance_t inst, unsigned int parentId);
+	unsigned int FindObjectVariable(game::scriptInstance_t inst, unsigned int parentId, unsigned int id);
+	void RemoveObjectVariable(game::scriptInstance_t inst, unsigned int parentId, unsigned int id);
+	game::VariableValueInternal_u* GetVariableValueAddress(game::scriptInstance_t inst, unsigned int id);
+	void Scr_KillEndonThread(game::scriptInstance_t inst, unsigned int threadId);
+	BOOL IsValidArrayIndex(game::scriptInstance_t inst, unsigned int unsignedValue);
+	void RemoveArrayVariable(game::scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	void SafeRemoveArrayVariable(game::scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	void AddRefToVector(game::scriptInstance_t inst, const float* vecVal);
+	unsigned int FindArrayVariableIndex(game::scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	unsigned int GetVariableIndexInternal(game::scriptInstance_t inst, unsigned int parentId, unsigned int name);
+	unsigned int GetNewVariableIndexInternal(game::scriptInstance_t inst, unsigned int parentId, unsigned int name);
+	unsigned int AllocObject(game::scriptInstance_t inst);
+	game::VariableType GetValueType(game::scriptInstance_t inst, unsigned int id);
+	game::VariableType GetObjectType(game::scriptInstance_t inst, unsigned int id);
+	float* Scr_AllocVector_(game::scriptInstance_t inst, const float* v);
+	void Scr_EvalInequality(game::scriptInstance_t inst, game::VariableValue* value1, game::VariableValue* value2);
+	unsigned int Scr_EvalArrayRefInternal(game::scriptInstance_t inst, game::VariableValue* varValue, game::VariableValueInternal* parentValue);
+	unsigned int GetNewArrayVariableIndex(game::scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	unsigned int GetNewArrayVariable(game::scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	unsigned int GetArrayVariable(game::scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	unsigned int AllocThread(game::scriptInstance_t inst, unsigned int self);
+}

src/codsrc/clientscript/cscr_vm.hpp

@@ -0,0 +1,119 @@
+#pragma once
+
+namespace codsrc
+{
+	void Scr_VM_Init(game::scriptInstance_t inst);
+	void Scr_Init(game::scriptInstance_t inst);
+	void Scr_Shutdown(game::scriptInstance_t inst);
+	void Scr_ErrorInternal(game::scriptInstance_t inst);
+	void Scr_ClearOutParams(game::scriptInstance_t inst);
+	unsigned int GetDummyObject(game::scriptInstance_t inst);
+	unsigned int GetDummyFieldValue(game::scriptInstance_t inst);
+	unsigned int VM_ExecuteInternal(game::scriptInstance_t inst);
+	void VM_CancelNotifyInternal(game::scriptInstance_t inst, unsigned int notifyListOwnerId, unsigned int startLocalId, unsigned int notifyListId, unsigned int notifyNameListId, unsigned int stringValue);
+	void VM_CancelNotify(game::scriptInstance_t inst, unsigned int a2, unsigned int a3);
+	game::VariableStackBuffer* VM_ArchiveStack(game::scriptInstance_t inst);
+	int Scr_AddLocalVars(game::scriptInstance_t inst, unsigned int a2);
+	void VM_UnarchiveStack(game::scriptInstance_t inst, unsigned int startLocalId, game::VariableStackBuffer* stackValue);
+	void VM_TerminateStack(game::scriptInstance_t inst, unsigned int a2, unsigned int a3, game::VariableStackBuffer* name);
+	void VM_TrimStack(game::scriptInstance_t inst, unsigned int parentId, game::VariableStackBuffer* a3, int fromEndon);
+	void Scr_TerminateRunningThread(game::scriptInstance_t inst, unsigned int a2);
+	void Scr_TerminateWaitThread(game::scriptInstance_t inst, unsigned int a2, unsigned int a3);
+	void Scr_CancelWaittill(game::scriptInstance_t inst, unsigned int startLocalId);
+	void Scr_TerminateWaittillThread(game::scriptInstance_t inst, unsigned int a2, unsigned int a3);
+	void Scr_TerminateThread(unsigned int a2, game::scriptInstance_t inst);
+	void VM_Notify(game::scriptInstance_t inst, int notifyListOwnerId, unsigned int stringValue, game::VariableValue* top);
+	void Scr_NotifyNum_Internal(game::scriptInstance_t inst, int entNum, unsigned int entClass, unsigned int notifStr, unsigned int numParams);
+	void Scr_CancelNotifyList(unsigned int notifyListOwnerId, game::scriptInstance_t inst);
+	void VM_TerminateTime(game::scriptInstance_t inst, unsigned int parentId);
+	void VM_Resume(game::scriptInstance_t inst, unsigned int timeId);
+	unsigned int VM_Execute(game::scriptInstance_t inst, unsigned int localId, const char* pos, unsigned int paramcount);
+	unsigned short Scr_ExecThread(game::scriptInstance_t inst, unsigned int handle, unsigned int paramCount);
+	unsigned short Scr_ExecEntThreadNum(game::scriptInstance_t inst, int entNum, unsigned int handle, int numParams, unsigned int entClass);
+	void Scr_AddExecThread(game::scriptInstance_t inst, unsigned int handle);
+	void VM_SetTime(game::scriptInstance_t inst);
+	void Scr_InitSystem(game::scriptInstance_t inst);
+	void Scr_ShutdownSystem(game::scriptInstance_t inst, int bComplete);
+	bool Scr_IsSystemActive();
+	int Scr_GetInt(game::scriptInstance_t inst, unsigned int index);
+	game::scr_anim_s Scr_GetAnim(unsigned int index, game::XAnimTree_s* anims);
+	game::scr_animtree_t Scr_GetAnimTree();
+	float Scr_GetFloat(game::scriptInstance_t inst, unsigned int index);
+	unsigned int Scr_GetConstString(game::scriptInstance_t inst, unsigned int index);
+	unsigned int Scr_GetConstLowercaseString(game::scriptInstance_t inst, unsigned int index);
+	const char* Scr_GetString(unsigned int index, game::scriptInstance_t inst);
+	unsigned int Scr_GetConstStringIncludeNull(game::scriptInstance_t inst);
+	char* Scr_GetDebugString(game::scriptInstance_t inst, unsigned int index);
+	unsigned int Scr_GetConstIString(unsigned int index);
+	void Scr_GetVector(game::scriptInstance_t inst, float* vectorValue, unsigned int index);
+	unsigned int Scr_GetFunc();
+	game::scr_entref_t* Scr_GetEntityRef(game::scriptInstance_t inst, game::scr_entref_t* retstr, unsigned int index);
+	game::VariableUnion Scr_GetObject(game::scriptInstance_t inst);
+	game::VariableType Scr_GetType(game::scriptInstance_t inst, unsigned int index);
+	const char* Scr_GetTypeName(game::scriptInstance_t inst);
+	game::VariableType Scr_GetPointerType(game::scriptInstance_t inst, unsigned int index);
+	void Scr_AddInt(game::scriptInstance_t inst, int value);
+	void Scr_AddFloat(game::scriptInstance_t inst, float value);
+	void Scr_AddAnim(game::scr_anim_s value);
+	void Scr_AddUndefined(game::scriptInstance_t inst);
+	void Scr_AddObject(game::scriptInstance_t inst, unsigned int entid);
+	void Scr_AddString(game::scriptInstance_t inst, const char* string);
+	void Scr_AddIString(const char* string);
+	void Scr_AddConstString(game::scriptInstance_t inst, unsigned int id);
+	void Scr_AddVector(game::scriptInstance_t inst, float* value);
+	void Scr_MakeArray(game::scriptInstance_t inst);
+	void Scr_AddArray(game::scriptInstance_t inst);
+	void Scr_AddArrayStringIndexed(unsigned int id, game::scriptInstance_t inst);
+	void Scr_Error(const char* error, game::scriptInstance_t inst, int is_terminal);
+	void Scr_TerminalError(game::scriptInstance_t inst, const char* error);
+	void Scr_ParamError(unsigned int index, game::scriptInstance_t inst, const char* error);
+	void Scr_ObjectError(game::scriptInstance_t inst, const char* error);
+	bool SetEntityFieldValue(game::scriptInstance_t inst, int offset, int entnum, game::classNum_e classnum, int clientNum, game::VariableValue* value);
+	game::VariableValue GetEntityFieldValue(int offset, int entnum, game::scriptInstance_t inst, game::classNum_e classnum, int clientNum);
+	void Scr_SetStructField(unsigned int structId, unsigned int index, game::scriptInstance_t inst);
+	void Scr_IncTime(game::scriptInstance_t inst);
+	void Scr_RunCurrentThreads(game::scriptInstance_t inst);
+	void Scr_ResetTimeout(game::scriptInstance_t inst);
+
+	void SetVariableFieldValue(game::scriptInstance_t inst, unsigned int id, game::VariableValue* value);
+	void SetNewVariableValue(game::scriptInstance_t inst, unsigned int id, game::VariableValue* value);
+	void Scr_ClearErrorMessage(game::scriptInstance_t inst);
+	void VM_Shutdown(game::scriptInstance_t inst);
+	void Scr_ShutdownVariables(game::scriptInstance_t inst);
+	void ClearVariableValue(game::scriptInstance_t inst, unsigned int id);
+	unsigned int Scr_GetThreadNotifyName(game::scriptInstance_t inst, unsigned int startLocalId);
+	void Scr_RemoveThreadNotifyName(game::scriptInstance_t inst, unsigned int startLocalId);
+	unsigned int GetArraySize(game::scriptInstance_t inst, unsigned int id);
+	void IncInParam(game::scriptInstance_t inst);
+	unsigned int GetParentLocalId(game::scriptInstance_t inst, unsigned int threadId);
+	void Scr_ClearWaitTime(game::scriptInstance_t inst, unsigned int startLocalId);
+	void Scr_SetThreadWaitTime(game::scriptInstance_t inst, unsigned int startLocalId, unsigned int waitTime);
+	void Scr_SetThreadNotifyName(game::scriptInstance_t inst, unsigned int startLocalId, unsigned int stringValue);
+	void Scr_DebugTerminateThread(game::scriptInstance_t inst, int topThread);
+	unsigned int Scr_GetThreadWaitTime(game::scriptInstance_t inst, unsigned int startLocalId);
+	const char* Scr_GetStackThreadPos(game::scriptInstance_t inst, unsigned int endLocalId, game::VariableStackBuffer* stackValue, bool killThread);
+	unsigned int Scr_GetSelf(game::scriptInstance_t inst, unsigned int threadId);
+	unsigned int GetVariableKeyObject(game::scriptInstance_t inst, unsigned int id);
+	int MT_Realloc(game::scriptInstance_t inst, int oldNumBytes, int newNumbytes);
+	void CScr_GetObjectField(game::classNum_e classnum, int entnum, int clientNum, int offset);
+	int CScr_SetObjectField(game::classNum_e classnum, int entnum, int clientNum, int offset);
+	void Scr_SetErrorMessage(game::scriptInstance_t inst, const char* error);
+	bool Scr_IsStackClear(game::scriptInstance_t inst);
+	void SL_CheckExists(game::scriptInstance_t inst, unsigned int stringValue);
+	const char* Scr_ReadCodePos(game::scriptInstance_t inst, const char** pos);
+	unsigned int Scr_ReadUnsignedInt(game::scriptInstance_t inst, const char** pos);
+	unsigned short Scr_ReadUnsignedShort(game::scriptInstance_t inst, const char** pos);
+	unsigned char Scr_ReadUnsignedByte(game::scriptInstance_t inst, const char** pos);
+	float Scr_ReadFloat(game::scriptInstance_t inst, const char** pos);
+	const float* Scr_ReadVector(game::scriptInstance_t inst, const char** pos);
+	BOOL IsFieldObject(game::scriptInstance_t inst, unsigned int id);
+	void RemoveVariableValue(game::scriptInstance_t inst, unsigned int parentId, unsigned int index);
+	game::VariableStackBuffer* GetRefVariableStackBuffer(game::scriptInstance_t inst, int id);
+	unsigned int GetNewObjectVariableReverse(game::scriptInstance_t inst, unsigned int parentId, unsigned int id);
+	unsigned int GetNewVariableIndexReverseInternal(game::scriptInstance_t inst, unsigned int parentId, unsigned int name);
+	unsigned int Scr_GetLocalVar(game::scriptInstance_t inst, int pos);
+	void Scr_EvalBoolNot(game::scriptInstance_t inst, game::VariableValue* value);
+	unsigned int GetInternalVariableIndex(game::scriptInstance_t inst, unsigned int unsignedValue);
+	const char* Scr_ReadData(game::scriptInstance_t inst, const char** pos, unsigned int count);
+	void Scr_NotifyNum(int entnum, game::classNum_e classnum, unsigned int stringValue, unsigned int paramcount);
+}