diff --git a/premake5.lua b/premake5.lua
index f766c7d..52c686c 100644
--- a/premake5.lua
+++ b/premake5.lua
@@ -50,6 +50,8 @@ workspace "t4sp-server-plugin"
 	warnings "Extra"
 	characterset "ASCII"
 
+	defines { "_CRT_SECURE_NO_WARNINGS" }
+
 	flags
 	{
 		"NoIncrementalLink",
diff --git a/src/codsrc/clientscript/clientscript_public - Copy.hpp b/src/codsrc/clientscript/clientscript_public - Copy.hpp
new file mode 100644
index 0000000..2644169
--- /dev/null
+++ b/src/codsrc/clientscript/clientscript_public - Copy.hpp	
@@ -0,0 +1,2 @@
+#include <stdinc.hpp>
+#include "clientscript_public.hpp"
diff --git a/src/codsrc/clientscript/cscr_main.cpp b/src/codsrc/clientscript/cscr_main.cpp
index 8c2bfa1..ad69e16 100644
--- a/src/codsrc/clientscript/cscr_main.cpp
+++ b/src/codsrc/clientscript/cscr_main.cpp
@@ -59,7 +59,7 @@ namespace codsrc
 
         game::VariableValue val = game::Scr_EvalVariable(inst, filePosId);
 
-        assert(val.type == VAR_CODEPOS);
+        assert(val.type == game::VAR_CODEPOS);
 
         const char* pos = val.u.codePosValue;
         if (!game::Scr_IsInOpcodeMemory(inst, pos))
@@ -278,7 +278,7 @@ namespace codsrc
             formatExtString = "%s.csc";
         }
 
-        game::Com_sprintf(extFilename, 64, game::Com_sprintf_ADDR(), formatExtString, filename);
+        snprintf(extFilename, 64, formatExtString, filename);
         oldSourceBuf = game::gScrParserPub[inst].sourceBuf;
         codepos = (const char *)game::TempMalloc(0);
         sourceBuffer = game::Scr_AddSourceBuffer(inst, (int)filename, extFilename, codepos);
@@ -324,6 +324,10 @@ namespace codsrc
     // Decomp Status: Tested, Completed
     void Scr_EndLoadScripts(game::scriptInstance_t inst)
     {
+        // pluto
+        game::plutonium::load_custom_script_func(inst);
+        //
+
         game::SL_ShutdownSystem(inst, 2u);
         game::gScrCompilePub[inst].script_loading = 0;
         
@@ -376,10 +380,6 @@ namespace codsrc
 
         assert(game::gScrAnimPub[inst].animtrees);
 
-        // pluto
-        game::plutonium::load_custom_script_func(inst);
-        //
-
         game::ClearObject(game::gScrAnimPub[inst].animtrees, inst);
         game::RemoveRefToObject(game::gScrAnimPub[inst].animtrees, inst);
         animtreeNode = game::gScrAnimPub[inst].animtree_node;
@@ -403,7 +403,7 @@ namespace codsrc
     // Decomp Status: Tested, Completed
     void Scr_FreeScripts(game::scriptInstance_t inst)
     {
-        char sys = 1;
+        //char sys = 1;
 
         //assert(sys == SCR_SYS_GAME);
 
diff --git a/src/component/decomp/clientscript/re_cscr_main.cpp b/src/component/decomp/clientscript/re_cscr_main.cpp
index f4dfd7f..ee943c6 100644
--- a/src/component/decomp/clientscript/re_cscr_main.cpp
+++ b/src/component/decomp/clientscript/re_cscr_main.cpp
@@ -223,7 +223,6 @@ namespace re_cscr_main
 		void Scr_EndLoadScripts_stub(game::scriptInstance_t inst, [[maybe_unused]] void* caller_addr)
 		{
 #ifdef RE_CSCR_MAIN_USE_WRAPPERS
-			game::plutonium::load_custom_script_func(inst);
 			Scr_EndLoadScripts_hook.invoke<void>(inst);
 #else
 			codsrc::Scr_EndLoadScripts(inst);
@@ -276,13 +275,13 @@ namespace re_cscr_main
 		void post_unpack() override
 		{
 			Scr_IsIdentifier_hook.create(game::Scr_IsIdentifier_ADDR(), Scr_IsIdentifier_stub);
-			Scr_GetFunctionHandle_hook.create(game::Scr_GetFunctionHandle_ADDR(), Scr_GetFunctionHandle_stub);
+			//Scr_GetFunctionHandle_hook.create(game::Scr_GetFunctionHandle_ADDR(), Scr_GetFunctionHandle_stub);
 			SL_TransferToCanonicalString_hook.create(game::SL_TransferToCanonicalString_ADDR(), SL_TransferToCanonicalString_stub);
 			SL_GetCanonicalString_hook.create(game::SL_GetCanonicalString_ADDR(), SL_GetCanonicalString_stub);
-			Scr_BeginLoadScripts_hook.create(game::Scr_BeginLoadScripts_ADDR(), Scr_BeginLoadScripts_stub);
+			//Scr_BeginLoadScripts_hook.create(game::Scr_BeginLoadScripts_ADDR(), Scr_BeginLoadScripts_stub);
 			Scr_BeginLoadAnimTrees_hook.create(game::Scr_BeginLoadAnimTrees_ADDR(), Scr_BeginLoadAnimTrees_stub);
 			Scr_ScanFile_hook.create(game::Scr_ScanFile_ADDR(), Scr_ScanFile_stub);
-			Scr_LoadScriptInternal_hook.create(game::Scr_LoadScriptInternal.get(), Scr_LoadScriptInternal_stub);
+			//Scr_LoadScriptInternal_hook.create(game::Scr_LoadScriptInternal.get(), Scr_LoadScriptInternal_stub);
 			Scr_LoadScript_hook.create(game::Scr_LoadScript_ADDR(), Scr_LoadScript_stub);
 			Scr_EndLoadScripts_hook.create(game::Scr_EndLoadScripts.get(), Scr_EndLoadScripts_stub);
 			Scr_PrecacheAnimTrees_hook.create(game::Scr_PrecacheAnimTrees.get(), Scr_PrecacheAnimTrees_stub);
diff --git a/src/game/clientscript/clientscript_public.hpp b/src/game/clientscript/clientscript_public.hpp
index 66d9225..15e449f 100644
--- a/src/game/clientscript/clientscript_public.hpp
+++ b/src/game/clientscript/clientscript_public.hpp
@@ -2170,6 +2170,40 @@ namespace game
 	ASSERT_STRUCT_OFFSET(node_field_t, type, 0x8);
 	ASSERT_STRUCT_OFFSET(node_field_t, getter, 0xC);
 
+	struct yy_buffer_state
+	{
+		_iobuf * yy_input_file; //OFS: 0x0 SIZE: 0x4
+		char * yy_ch_buf; //OFS: 0x4 SIZE: 0x4
+		char * yy_buf_pos; //OFS: 0x8 SIZE: 0x4
+		unsigned int yy_buf_size; //OFS: 0xC SIZE: 0x4
+		int yy_n_chars; //OFS: 0x10 SIZE: 0x4
+		int yy_is_our_buffer; //OFS: 0x14 SIZE: 0x4
+		int yy_is_interactive; //OFS: 0x18 SIZE: 0x4
+		int yy_at_bol; //OFS: 0x1C SIZE: 0x4
+		int yy_fill_buffer; //OFS: 0x20 SIZE: 0x4
+		int yy_buffer_status; //OFS: 0x24 SIZE: 0x4
+	};
+	ASSERT_STRUCT_SIZE(yy_buffer_state, 0x28);
+	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_input_file, 0x0);
+	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_ch_buf, 0x4);
+	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buf_pos, 0x8);
+	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buf_size, 0xC);
+	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_n_chars, 0x10);
+	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_is_our_buffer, 0x14);
+	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_is_interactive, 0x18);
+	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_at_bol, 0x1C);
+	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_fill_buffer, 0x20);
+	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buffer_status, 0x24);
+
+	struct stype_t
+	{
+		sval_u val; //OFS: 0x0 SIZE: 0x4
+		unsigned int pos; //OFS: 0x4 SIZE: 0x4
+	};
+	ASSERT_STRUCT_SIZE(stype_t, 0x8);
+	ASSERT_STRUCT_OFFSET(stype_t, val, 0x0);
+	ASSERT_STRUCT_OFFSET(stype_t, pos, 0x4);
+
 #pragma endregion
 
 #ifdef __cplusplus
@@ -2196,12 +2230,68 @@ namespace game
 	WEAK symbol<scrParserPub_t> gScrParserPub{ 0x0, 0x3882B00 };
 	WEAK symbol<scr_classStruct_t*> gScrClassMap{ 0x0, 0x8CF568 };
 	WEAK symbol<scr_const_t> scr_const{ 0x0, 0x1F33B90 };
+	WEAK symbol<bool> loadedImpureScript{ 0x0, 0x22C1352 };
+
+	WEAK symbol<unsigned char> g_parse_user{ 0x0, 0x234F72E };
+	WEAK symbol<scriptInstance_t> gInst{ 0x0, 0x3BE624C };
+	WEAK symbol<int> yynerrs{ 0x0, 0x3BE6264 };
+	WEAK symbol<int> yychar{ 0x0, 0x3BE6260 };
+	WEAK symbol<stype_t> yylval{ 0x0, 0x3BE6240 };
+	WEAK symbol<unsigned int> g_sourcePos{ 0x0, 0x3BE623C };
+	WEAK symbol<sval_u> yaccResult{ 0x0, 0x3BE6258 };
+	WEAK symbol<sval_u> g_dummyVal{ 0x0, 0x3BE6254 };
+	WEAK symbol<int> yy_init{ 0x0, 0x8CF4A0 };
+	WEAK symbol<int> yy_start{ 0x0, 0x46E54D4 };
+	WEAK symbol<_iobuf*> yyin{ 0x0, 0x46E54D8 };
+	WEAK symbol<_iobuf*> yyout{ 0x0, 0x46E54DC };
+	WEAK symbol<yy_buffer_state*> yy_current_buffer{ 0x0, 0x46E54CC };
+	WEAK symbol<int> yy_n_chars{ 0x0, 0x3BE6250 };
+	WEAK symbol<char> yy_hold_char{ 0x0, 0x22C1353 };
+	WEAK symbol<int> yy_c_buf_p{ 0x0, 0x46E54D0 };
+	WEAK symbol<int> yy_last_accepting_state{ 0x0, 0x3BE626C };
+	WEAK symbol<char*> yy_last_accepting_cpos{ 0x0, 0x3BE2230 };
+	WEAK symbol<size_t> yyleng{ 0x0, 0x3BE6248 };
+	WEAK symbol<char*> yytext{ 0x0, 0x3BE2234 };
+	WEAK symbol<int> yy_did_buffer_switch_on_eof{ 0x0, 0x3BE6268 };
+	WEAK symbol<unsigned int> g_out_pos{ 0x0, 0x3BE625C };
+	WEAK symbol<char> ch_buf{ 0x0, 0x3BE2238 };
+	WEAK symbol<short> yypact{ 0x0, 0x82F2D0 };
+	WEAK symbol<char> yytranslate{ 0x0, 0x82ED08 };
+	WEAK symbol<short> yycheck{ 0x0, 0x82FFA0 };
+	WEAK symbol<short> yytable{ 0x0, 0x82F518 };
+	WEAK symbol<short> yyr1{ 0x0, 0x82EE68 };
+	WEAK symbol<short> yyr2{ 0x0, 0x82EF78 };
+	WEAK symbol<short> yydefact{ 0x0, 0x82F088 };
+	WEAK symbol<int> yy_ec{ 0x0, 0x830C30 };
+	WEAK symbol<short> yy_accept{ 0x0, 0x830A28 };
+	WEAK symbol<short> yy_chk{ 0x0, 0x831930 };
+	WEAK symbol<short> yy_base{ 0x0, 0x831120 };
+	WEAK symbol<short> yy_def{ 0x0, 0x831338 };
+	WEAK symbol<short> yy_nxt{ 0x0, 0x831550 };
+	WEAK symbol<unsigned char> yy_meta{ 0x0, 0x831030 };
 #pragma endregion
 
 #pragma region "functions"
+	WEAK symbol<BOOL(LPVOID lpAddress)>Hunk_UserDestroy{ 0x0, 0x5E4940 };
 
+	inline void* ScriptParse_ADDR() { return CALL_ADDR(0x0, 0x69D710); }
+	void ScriptParse(scriptInstance_t inst, sval_u* parseData, void* call_addr = ScriptParse_ADDR());
+	inline void* ScriptCompile_ADDR() { return CALL_ADDR(0x0, 0x688E70); }
+	void ScriptCompile(scriptInstance_t inst, sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry * entries, int entriesCount, void* call_addr = ScriptCompile_ADDR());
+	inline void* Scr_LoadAnimTreeAtIndex_ADDR() { return CALL_ADDR(0x0, 0x67E7D0); }
+	void Scr_LoadAnimTreeAtIndex(scriptInstance_t inst, int user, unsigned int index, void* (__cdecl* Alloc)(int), int modCheckSum, void* call_addr = Scr_LoadAnimTreeAtIndex_ADDR());
+	inline void* Hunk_UserCreate_ADDR() { return CALL_ADDR(0x0, 0x5E46E0); }
+	HunkUser* Hunk_UserCreate(signed int maxSize, const char* name, int fixed, int tempMem, int debugMem, int type, void* call_addr = Hunk_UserCreate_ADDR());
 #pragma endregion
 }
 
 #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"
 #endif
diff --git a/src/game/clientscript/clientscript_public_w.cpp b/src/game/clientscript/clientscript_public_w.cpp
index 43b100a..73215b6 100644
--- a/src/game/clientscript/clientscript_public_w.cpp
+++ b/src/game/clientscript/clientscript_public_w.cpp
@@ -1 +1,69 @@
 #include <stdinc.hpp>
+
+namespace game
+{
+	// void __usercall ScriptParse(scriptInstance_t a1@<eax>, sval_u *parseData)
+	void ScriptParse(scriptInstance_t inst, sval_u* parseData, void* call_addr)
+	{
+		__asm
+		{
+			push parseData;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall ScriptCompile(scriptInstance_t inst@<eax>, sval_u a2, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry *entries, int entriesCount)
+	void ScriptCompile(scriptInstance_t inst, sval_u val, unsigned int filePosId, unsigned int fileCountId, unsigned int scriptId, PrecacheEntry * entries, int entriesCount, void* call_addr)
+	{
+		__asm
+		{
+			push entriesCount;
+			push entries;
+			push scriptId;
+			push fileCountId;
+			push filePosId;
+			push val;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0x18;
+		}
+	}
+
+	// void __usercall Scr_LoadAnimTreeAtIndex(scriptInstance_t inst@<ecx>, int a2@<eax>, int a3, int (__cdecl *a4)(int), int a5)
+	void Scr_LoadAnimTreeAtIndex(scriptInstance_t inst, int user, unsigned int index, void* (__cdecl* Alloc)(int), int modCheckSum, void* call_addr)
+	{
+		__asm
+		{
+			push modCheckSum;
+			push Alloc;
+			push index;
+			mov eax, user;
+			mov ecx, inst;
+			call call_addr;
+			add esp, 0xC;
+		}
+	}
+
+	// HunkUser* __usercall Hunk_UserCreate@<eax>(signed int maxSize@<edi>, char* name, char fixed, char tempMem, char debugMem, int type);
+	HunkUser* Hunk_UserCreate(signed int maxSize, const char* name, int fixed, int tempMem, int debugMem, int typ, void* call_addr)
+	{
+		HunkUser* answer;
+
+		__asm
+		{
+			push typ;
+			push debugMem;
+			push tempMem;
+			push fixed;
+			push name;
+			mov edi, maxSize;
+			call call_addr;
+			add esp, 0x14;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_memorytree.hpp b/src/game/clientscript/cscr_memorytree.hpp
new file mode 100644
index 0000000..23e6b5b
--- /dev/null
+++ b/src/game/clientscript/cscr_memorytree.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+namespace game
+{
+	WEAK symbol<int(scriptInstance_t inst, int nodeNum)>MT_GetSubTreeSize{ 0x0, 0x689EF0 };
+	WEAK symbol<void(scriptInstance_t inst)>MT_DumpTree{ 0x0, 0x689F40 };
+	WEAK symbol<void(scriptInstance_t inst, int newNode, int size)>MT_AddMemoryNode{ 0x0, 0x68A0E0 };
+	WEAK symbol<char(scriptInstance_t inst, int oldNode, int size)>MT_RemoveMemoryNode{ 0x0, 0x68A280 };
+	WEAK symbol<void(scriptInstance_t inst, int size)>MT_RemoveHeadMemoryNode{ 0x0, 0x68A3E0 };
+	WEAK symbol<void(void* p, int numBytes, scriptInstance_t inst)>MT_Free{ 0x0, 0x68A800 };
+
+	inline void* MT_InitBits_ADDR() { return CALL_ADDR(0x0, 0x68A010); }
+	void MT_InitBits(scriptInstance_t inst, void* call_addr = MT_InitBits_ADDR());
+	inline void* MT_GetScore_ADDR() { return CALL_ADDR(0x0, 0x68A080); }
+	int MT_GetScore(scriptInstance_t inst, int num, void* call_addr = MT_GetScore_ADDR());
+	inline void* MT_Init_ADDR() { return CALL_ADDR(0x0, 0x68A4F0); }
+	void MT_Init(scriptInstance_t inst, void* call_addr = MT_Init_ADDR());
+	inline void* MT_Error_ADDR() { return CALL_ADDR(0x0, 0x68A580); }
+	void MT_Error(scriptInstance_t inst, const char* funcName, int numBytes, void* call_addr = MT_Error_ADDR());
+	inline void* MT_GetSize_ADDR() { return CALL_ADDR(0x0, 0x68A5D0); }
+	int MT_GetSize(int numBytes, scriptInstance_t inst, void* call_addr = MT_GetSize_ADDR());
+	inline void* MT_AllocIndex_ADDR() { return CALL_ADDR(0x0, 0x68A630); }
+	unsigned __int16 MT_AllocIndex(scriptInstance_t inst, int size_, void* call_addr = MT_AllocIndex_ADDR());
+	inline void* MT_FreeIndex_ADDR() { return CALL_ADDR(0x0, 0x68A750); }
+	void MT_FreeIndex(int numBytes, scriptInstance_t inst, int nodeNum, void* call_addr = MT_FreeIndex_ADDR());
+	inline void* MT_Alloc_ADDR() { return CALL_ADDR(0x0, 0x68A7D0); }
+	char* MT_Alloc(int numBytes, scriptInstance_t inst, void* call_addr = MT_Alloc_ADDR());
+
+	RefVector* GetRefVector(scriptInstance_t inst, unsigned int id);
+	const char* MT_NodeInfoString(scriptInstance_t inst, unsigned int nodeNum);
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_memorytree_w.cpp b/src/game/clientscript/cscr_memorytree_w.cpp
new file mode 100644
index 0000000..d4a7c73
--- /dev/null
+++ b/src/game/clientscript/cscr_memorytree_w.cpp
@@ -0,0 +1,128 @@
+#include <stdinc.hpp>
+
+namespace game
+{
+	// void __usercall MT_InitBits(scriptInstance_t a1@<ecx>)
+	void MT_InitBits(scriptInstance_t inst, void* call_addr)
+	{
+		__asm
+		{
+			mov ecx, inst;
+			call call_addr;
+		}
+	}
+
+	// int __usercall MT_GetScore@<eax>(scriptInstance_t a1@<edx>, int num)
+	int MT_GetScore(scriptInstance_t inst, int num, void* call_addr)
+	{
+		int answer;
+
+		__asm
+		{
+			push num;
+			mov edx, inst;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+
+		return answer;
+	}
+
+	// void __usercall MT_Init(scriptInstance_t a1@<edi>)
+	void MT_Init(scriptInstance_t inst, void* call_addr)
+	{
+		__asm
+		{
+			mov edi, inst;
+			call call_addr;
+		}
+	}
+
+	// void __usercall MT_Error(scriptInstance_t a1@<eax>, const char *funcName, int numBytes)
+	void MT_Error(scriptInstance_t inst, const char* funcName, int numBytes, void* call_addr)
+	{
+		__asm
+		{
+			push numBytes;
+			push funcName;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// int __usercall MT_GetSize@<eax>(int numBytes@<eax>, scriptInstance_t inst@<ecx>)
+	int MT_GetSize/*@<eax>*/(int numBytes/*@<eax>*/, scriptInstance_t inst/*@<ecx>*/, void* call_addr)
+	{
+		int answer;
+
+		__asm
+		{
+			mov eax, numBytes;
+			mov ecx, inst;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	// unsigned __int16 __usercall MT_AllocIndex@<ax>(scriptInstance_t inst@<edi>, int size)
+	unsigned __int16 MT_AllocIndex/*@<ax>*/(scriptInstance_t inst/*@<edi>*/, int size_, void* call_addr)
+	{
+		unsigned __int16 answer;
+
+		__asm
+		{
+			push size_;
+			mov edi, inst;
+			call call_addr;
+			mov answer, ax;
+			add esp, 0x4;
+		}
+
+		return answer;
+	}
+
+	// void __usercall MT_FreeIndex(int numBytes@<eax>, scriptInstance_t a1, int nodeNum)
+	void MT_FreeIndex(int numBytes/*@<eax>*/, scriptInstance_t inst, int nodeNum, void* call_addr)
+	{
+		__asm
+		{
+			push nodeNum;
+			push inst;
+			mov eax, numBytes;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// char *__usercall MT_Alloc@<eax>(int numBytes@<eax>, scriptInstance_t a2@<ecx>)
+	char* MT_Alloc(int numBytes, scriptInstance_t inst, void* call_addr)
+	{
+		char* answer;
+
+		__asm
+		{
+			mov eax, numBytes;
+			mov ecx, inst;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+	
+	RefVector* GetRefVector(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_memorytree::GetRefVector(inst, id);
+		return nullptr;
+	}
+
+	const char* MT_NodeInfoString(scriptInstance_t inst, unsigned int nodeNum)
+	{
+		//return cscr_memorytree::MT_NodeInfoString(inst, nodeNum);
+		return nullptr;
+	}
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_parser.hpp b/src/game/clientscript/cscr_parser.hpp
new file mode 100644
index 0000000..e2803d9
--- /dev/null
+++ b/src/game/clientscript/cscr_parser.hpp
@@ -0,0 +1,52 @@
+#pragma once
+
+namespace game
+{
+	WEAK symbol<char* (scriptInstance_t inst, int unused, char* filename, const char* codepos, int archive)>Scr_ReadFile_FastFile{ 0x0, 0x68AE30 };
+	WEAK symbol<char* (scriptInstance_t inst, int unused_arg1, const char* filename, const char* codepos, int archive)>Scr_ReadFile_LoadObj{ 0x0, 0x68AED0 };
+	WEAK symbol<void(scriptInstance_t inst, unsigned int codePos, const char* msg, ...)>CompileError{ 0x0, 0x68B470 };
+
+	inline void* Scr_InitOpcodeLookup_ADDR() { return CALL_ADDR(0x0, 0x68A840); }
+	void Scr_InitOpcodeLookup(scriptInstance_t inst, void* call_addr = Scr_InitOpcodeLookup_ADDR());
+	inline void* Scr_ShutdownOpcodeLookup_ADDR() { return CALL_ADDR(0x0, 0x68A950); }
+	void Scr_ShutdownOpcodeLookup(scriptInstance_t inst, void* call_addr = Scr_ShutdownOpcodeLookup_ADDR());
+	inline void* AddOpcodePos_ADDR() { return CALL_ADDR(0x0, 0x68A9A0); }
+	void AddOpcodePos(scriptInstance_t inst, unsigned int sourcePos, int type_, void* call_addr = AddOpcodePos_ADDR());
+	inline void* RemoveOpcodePos_ADDR() { return CALL_ADDR(0x0, 0x68AB80); }
+	void RemoveOpcodePos(scriptInstance_t inst, void* call_addr = RemoveOpcodePos_ADDR());
+	inline void* AddThreadStartOpcodePos_ADDR() { return CALL_ADDR(0x0, 0x68ABF0); }
+	void AddThreadStartOpcodePos(scriptInstance_t inst, unsigned int sourcePos, void* call_addr = AddThreadStartOpcodePos_ADDR());
+	inline void* Scr_GetSourceBuffer_ADDR() { return CALL_ADDR(0x0, 0x68B270); }
+	unsigned int Scr_GetSourceBuffer(scriptInstance_t inst, const char* codePos, void* call_addr = Scr_GetSourceBuffer_ADDR());
+	inline void* Scr_GetLineNumInternal_ADDR() { return CALL_ADDR(0x0, 0x68AC90); }
+	unsigned int Scr_GetLineNumInternal(const char** startLine, const char* buf, const char* sourcePos, int* col, void* call_addr = Scr_GetLineNumInternal_ADDR());
+	inline void* Scr_GetNewSourceBuffer_ADDR() { return CALL_ADDR(0x0, 0x68ACC0); }
+	SourceBufferInfo* Scr_GetNewSourceBuffer(scriptInstance_t inst, void* call_addr = Scr_GetNewSourceBuffer_ADDR());
+	inline void* Scr_AddSourceBufferInternal_ADDR() { return CALL_ADDR(0x0, 0x68AD50); }
+	void Scr_AddSourceBufferInternal(const char* filename, scriptInstance_t inst, const char* codepos, char* buffer, int len, int archive, void* call_addr = Scr_AddSourceBufferInternal_ADDR());
+	inline void* Scr_ReadFile_ADDR() { return CALL_ADDR(0x0, 0x68AFA0); }
+	char* Scr_ReadFile(const char* codepos, char* filename, scriptInstance_t inst, int unused, void* call_addr = Scr_ReadFile_ADDR());
+	inline void* Scr_AddSourceBuffer_ADDR() { return CALL_ADDR(0x0, 0x68B040); }
+	char* Scr_AddSourceBuffer(scriptInstance_t inst, int unused_arg1, char* filename, const char* codepos, void* call_addr = Scr_AddSourceBuffer_ADDR());
+	inline void* Scr_CopyFormattedLine_ADDR() { return CALL_ADDR(0x0, 0x68B0E0); }
+	void Scr_CopyFormattedLine(const char* rawLine, char* line, void* call_addr = Scr_CopyFormattedLine_ADDR());
+	inline void* Scr_GetLineInfo_ADDR() { return CALL_ADDR(0x0, 0x68B140); }
+	unsigned int Scr_GetLineInfo(int* col, const char* buf, unsigned int sourcePos, char* line, void* call_addr = Scr_GetLineInfo_ADDR());
+	inline void* Scr_PrintSourcePos_ADDR() { return CALL_ADDR(0x0, 0x68B190); }
+	void Scr_PrintSourcePos(unsigned int sourcePos, const char* buf, con_channel_e channel, scriptInstance_t inst, const char* file, void* call_addr = Scr_PrintSourcePos_ADDR());
+	inline void* Scr_GetPrevSourcePosOpcodeLookup_ADDR() { return CALL_ADDR(0x0, 0x68AC40); }
+	OpcodeLookup* Scr_GetPrevSourcePosOpcodeLookup(scriptInstance_t inst, const char* codePos, void* call_addr = Scr_GetPrevSourcePosOpcodeLookup_ADDR());
+	inline void* Scr_GetTextSourcePos_ADDR() { return CALL_ADDR(0x0, 0x68B2B0); }
+	void Scr_GetTextSourcePos(char* line, const char* codePos, scriptInstance_t inst, void* call_addr = Scr_GetTextSourcePos_ADDR());
+	inline void* Scr_PrintPrevCodePos_ADDR() { return CALL_ADDR(0x0, 0x68B340); }
+	void Scr_PrintPrevCodePos(const char* codepos, scriptInstance_t scriptInstance, con_channel_e channel, unsigned int index, void* call_addr = Scr_PrintPrevCodePos_ADDR());
+	inline void* CompileError2_ADDR() { return CALL_ADDR(0x0, 0x68B600); }
+	void CompileError2(const char* codePos, scriptInstance_t a2, void* call_addr, const char* msg, ...);
+	inline void* RuntimeErrorInternal_ADDR() { return CALL_ADDR(0x0, 0x68B6D0); }
+	void RuntimeErrorInternal(const char* msg, scriptInstance_t inst, con_channel_e channel, const char* codepos, int index, void* call_addr = RuntimeErrorInternal_ADDR());
+	inline void* RuntimeError_ADDR() { return CALL_ADDR(0x0, 0x68B790); }
+	void RuntimeError(scriptInstance_t inst, const char* pos, int error_index, const char* err, const char* err2, void* call_addr = RuntimeError_ADDR());
+
+	unsigned int Scr_GetPrevSourcePos(scriptInstance_t inst, const char* codePos, unsigned int index);
+	void Scr_ShutdownAllocNode(scriptInstance_t inst);
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_parser_w.cpp b/src/game/clientscript/cscr_parser_w.cpp
new file mode 100644
index 0000000..b739255
--- /dev/null
+++ b/src/game/clientscript/cscr_parser_w.cpp
@@ -0,0 +1,316 @@
+#include <stdinc.hpp>
+
+namespace game
+{
+	// void __usercall Scr_InitOpcodeLookup(scriptInstance_t a1@<eax>)
+	void Scr_InitOpcodeLookup(scriptInstance_t a1, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+		}
+	}
+
+	// void __usercall Scr_ShutdownOpcodeLookup(scriptInstance_t a1@<ecx>)
+	void Scr_ShutdownOpcodeLookup(scriptInstance_t a1, void* call_addr)
+	{
+		__asm
+		{
+			mov ecx, a1;
+			call call_addr;
+		}
+	}
+
+	// void __usercall AddOpcodePos(scriptInstance_t a1@<eax>, unsigned int sourcePos, int type)
+	void AddOpcodePos(scriptInstance_t a1, unsigned int sourcePos, int type_, void* call_addr)
+	{
+		__asm
+		{
+			push type_;
+			push sourcePos;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// void __usercall RemoveOpcodePos(scriptInstance_t result@<eax>)
+	void RemoveOpcodePos(scriptInstance_t result, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, result;
+			call call_addr;
+		}
+	}
+
+	// void __usercall AddThreadStartOpcodePos(scriptInstance_t result@<eax>, unsigned int sourcePos)
+	void AddThreadStartOpcodePos(scriptInstance_t result, unsigned int sourcePos, void* call_addr)
+	{
+		__asm
+		{
+			push sourcePos;
+			mov eax, result;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// unsigned int __usercall Scr_GetSourceBuffer@<eax>(scriptInstance_t inst@<eax>, const char *codePos@<esi>)
+	unsigned int Scr_GetSourceBuffer(scriptInstance_t a1, const char* codePos, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			mov eax, a1;
+			mov esi, codePos;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall Scr_GetLineNumInternal@<eax>(const char **startLine@<edx>, const char *buf@<ecx>, const char *sourcePos, int *col)
+	unsigned int Scr_GetLineNumInternal(const char** startLine, const char* buf, const char* sourcePos, int* col, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push col;
+			push sourcePos;
+			mov edx, startLine;
+			mov ecx, buf;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+
+		return answer;
+	}
+
+	// SourceBufferInfo *__usercall Scr_GetNewSourceBuffer@<eax>(scriptInstance_t a1@<eax>)
+	SourceBufferInfo* Scr_GetNewSourceBuffer(scriptInstance_t a1, void* call_addr)
+	{
+		SourceBufferInfo* answer;
+
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	// void __usercall Scr_AddSourceBufferInternal(const char *filename@<eax>, scriptInstance_t inst, const char *codepos, char *buffer, int len, int archive)
+	void Scr_AddSourceBufferInternal(const char* filename, scriptInstance_t inst, const char* codepos, char* buffer, int len, int archive, void* call_addr)
+	{
+		__asm
+		{
+			push archive;
+			push len;
+			push buffer;
+			push codepos;
+			push inst;
+			mov eax, filename;
+			call call_addr;
+			add esp, 0x14;
+		}
+	}
+
+	// char *__usercall Scr_ReadFile@<eax>(const char *codepos@<edi>, char *filename@<esi>, scriptInstance_t inst, int unused)
+	char* Scr_ReadFile(const char* codepos, char* filename, scriptInstance_t inst, int unused, void* call_addr)
+	{
+		char* answer;
+
+		__asm
+		{
+			push unused;
+			push inst;
+			mov edi, codepos;
+			mov esi, filename;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+
+		return answer;
+	}
+
+	// char *__usercall Scr_AddSourceBuffer@<eax>(scriptInstance_t inst@<eax>, int unused_arg1, char *filename, const char *codepos)
+	char* Scr_AddSourceBuffer(scriptInstance_t inst, int unused_arg1, char* filename, const char* codepos, void* call_addr)
+	{
+		char* answer;
+
+		__asm
+		{
+			push codepos;
+			push filename;
+			push unused_arg1;
+			mov eax, inst;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0xC;
+		}
+
+		return answer;
+	}
+
+	// void __usercall Scr_CopyFormattedLine(const char *rawLine@<eax>, char *line)
+	void Scr_CopyFormattedLine(const char* rawLine, char* line, void* call_addr)
+	{
+		__asm
+		{
+			push line;
+			mov eax, rawLine;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// unsigned int __usercall Scr_GetLineInfo@<eax>(int *col@<edx>, _BYTE *buf@<ecx>, unsigned int sourcePos, char *line)
+	unsigned int Scr_GetLineInfo(int* col, const char* buf, unsigned int sourcePos, char* line, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push line;
+			push sourcePos;
+			mov edx, col;
+			mov ecx, buf;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+
+		return answer;
+	}
+
+	// void __usercall Scr_PrintSourcePos(unsigned int sourcePos@<edx>, const char *buf@<ecx>, con_channel_e channel@<esi>, scriptInstance_t a4, const char *file)
+	void Scr_PrintSourcePos(unsigned int sourcePos, const char* buf, con_channel_e channel, scriptInstance_t a4, const char* file, void* call_addr)
+	{
+		__asm
+		{
+			push file;
+			push a4;
+			mov edx, sourcePos;
+			mov ecx, buf;
+			mov esi, channel;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// OpcodeLookup *__usercall Scr_GetPrevSourcePosOpcodeLookup@<eax>(scriptInstance_t a1@<eax>, const char *codePos@<edi>)
+	OpcodeLookup* Scr_GetPrevSourcePosOpcodeLookup(scriptInstance_t a1, const char* codePos, void* call_addr)
+	{
+		OpcodeLookup* answer;
+
+		__asm
+		{
+			mov eax, a1;
+			mov edi, codePos;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	// void __usercall Scr_GetTextSourcePos(char *line@<edx>, const char *codePos@<ecx>, scriptInstance_t a3)
+	void Scr_GetTextSourcePos(char* line, const char* codePos, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov edx, line;
+			mov ecx, codePos;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_PrintPrevCodePos(const char *codepos@<eax>, scriptInstance_t scriptInstance, con_channel_e channel, unsigned int index)
+	void Scr_PrintPrevCodePos(const char* codepos, scriptInstance_t scriptInstance, con_channel_e channel, unsigned int index, void* call_addr)
+	{
+		__asm
+		{
+			push index;
+			push channel;
+			push scriptInstance;
+			mov eax, codepos;
+			call call_addr;
+			add esp, 0xC;
+		}
+	}
+
+	//void __usercall CompileError2(const char *codePos@<edi>, scriptInstance_t a2@<esi>, char *msg, ...)
+	void CompileError2(const char* codePos, scriptInstance_t a2, void* call_addr, const char* msg, ...)
+	{
+		char Buffer[1024];
+		char* Buf = Buffer;
+		const char* str_ = "%s";
+		va_list ArgList;
+
+		va_start(ArgList, msg);
+		vsnprintf(Buffer, 0x400u, msg, ArgList);
+		va_end(ArgList);
+
+		__asm
+		{
+			push Buf;
+			push str_;
+			mov esi, a2;
+			mov edi, codePos;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// void __usercall RuntimeErrorInternal(const char *msg@<eax>, scriptInstance_t inst@<edi>, con_channel_e channel, const char *codepos, int index)
+	void RuntimeErrorInternal(const char* msg, scriptInstance_t inst, con_channel_e channel, const char* codepos, int index, void* call_addr)
+	{
+		__asm
+		{
+			push index;
+			push codepos;
+			push channel;
+			mov eax, msg;
+			mov edi, inst;
+			call call_addr;
+			add esp, 0xC;
+		}
+	}
+
+	// void __usercall RuntimeError(scriptInstance_t inst@<eax>, const char *pos, int error_index, const char *err, const char *err2)
+	void RuntimeError(scriptInstance_t inst, const char* pos, int error_index, const char* err, const char* err2, void* call_addr)
+	{
+		__asm
+		{
+			push err2;
+			push err;
+			push error_index;
+			push pos;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0x10;
+		}
+	}
+
+	unsigned int Scr_GetPrevSourcePos(scriptInstance_t inst, const char* codePos, unsigned int index)
+	{
+		//return cscr_parser::Scr_GetPrevSourcePos(inst, codePos, index);
+		return 0;
+	}
+
+	void Scr_ShutdownAllocNode(scriptInstance_t inst)
+	{
+		//cscr_parser::Scr_ShutdownAllocNode(inst);
+	}
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_parsetree.hpp b/src/game/clientscript/cscr_parsetree.hpp
new file mode 100644
index 0000000..177e942
--- /dev/null
+++ b/src/game/clientscript/cscr_parsetree.hpp
@@ -0,0 +1,20 @@
+#pragma once
+
+namespace game
+{
+	WEAK symbol<void(scriptInstance_t inst)>Scr_InitAllocNode{ 0x0, 0x68B870};
+	WEAK symbol<sval_u()>node0{ 0x0, 0x68B900};
+	WEAK symbol<sval_u(scr_enum_t type, sval_u val1)>node1{ 0x0, 0x68B920};
+	WEAK symbol<sval_u(scr_enum_t type, sval_u val1, sval_u val2)>node2{ 0x0, 0x68B950};
+	WEAK symbol<sval_u(scr_enum_t type, sval_u val1, sval_u val2, sval_u val3)>node3{ 0x0, 0x68B980};
+	WEAK symbol<sval_u(scr_enum_t type, sval_u val1, sval_u val2, sval_u val3, sval_u val4)>node4{ 0x0, 0x68B9C0};
+	WEAK symbol<sval_u(scr_enum_t type, sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_u val5)>node5{ 0x0, 0x68BA00};
+	WEAK symbol<sval_u(sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_u val5, sval_u val6)>node6{ 0x0, 0x68BA50};
+	WEAK symbol<sval_u(sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_u val5, sval_u val6, sval_u val7)>node7{ 0x0, 0x68BAA0};
+	WEAK symbol<sval_u(sval_u val1, sval_u val2, sval_u val3, sval_u val4, sval_u val5, sval_u val6, sval_u val7, sval_u val8)>node8{ 0x0, 0x68BB00};
+	WEAK symbol<sval_u(sval_u val1)>linked_list_end{ 0x0, 0x68BB60};
+	WEAK symbol<sval_u(sval_u val1, sval_u val2)>prepend_node{ 0x0, 0x68BBB0};
+	WEAK symbol<sval_u(sval_u val1, sval_u val2)>append_node{ 0x0, 0x68BBE0};
+
+	sval_u* Scr_AllocNode(scriptInstance_t inst, int size);
+}
diff --git a/src/game/clientscript/cscr_parsetree_w.cpp b/src/game/clientscript/cscr_parsetree_w.cpp
new file mode 100644
index 0000000..57102ee
--- /dev/null
+++ b/src/game/clientscript/cscr_parsetree_w.cpp
@@ -0,0 +1,10 @@
+#include <stdinc.hpp>
+
+namespace game
+{
+	sval_u* Scr_AllocNode(scriptInstance_t inst, int size)
+	{
+		//return cscr_parsetree::Scr_AllocNode(inst, size);
+		return nullptr;
+	}
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_readwrite.hpp b/src/game/clientscript/cscr_readwrite.hpp
new file mode 100644
index 0000000..5a33a9f
--- /dev/null
+++ b/src/game/clientscript/cscr_readwrite.hpp
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace game
+{
+	inline void* FindVariableIndexInternal2_ADDR() { return CALL_ADDR(0x0, 0x68BC20); }
+	unsigned int FindVariableIndexInternal2(scriptInstance_t inst, unsigned int name, unsigned int index, void* call_addr = FindVariableIndexInternal2_ADDR());
+	inline void* FindLastSibling_ADDR() { return CALL_ADDR(0x0, 0x68BCA0); }
+	unsigned int FindLastSibling(unsigned int parentId, scriptInstance_t inst, void* call_addr = FindLastSibling_ADDR());
+
+	unsigned int FindVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name);
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_readwrite_w.cpp b/src/game/clientscript/cscr_readwrite_w.cpp
new file mode 100644
index 0000000..5f8611a
--- /dev/null
+++ b/src/game/clientscript/cscr_readwrite_w.cpp
@@ -0,0 +1,44 @@
+#include <stdinc.hpp>
+
+namespace game
+{
+	// unsigned int __usercall FindVariableIndexInternal2@<eax>(scriptInstance_t inst@<eax>, unsigned int name, unsigned int index)
+	unsigned int FindVariableIndexInternal2(scriptInstance_t inst, unsigned int name, unsigned int index, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push index;
+			push name;
+			mov eax, inst;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall FindLastSibling@<eax>(unsigned int parentId@<edx>, scriptInstance_t inst@<esi>)
+	unsigned int FindLastSibling(unsigned int parentId, scriptInstance_t inst, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			mov edx, parentId;
+			mov esi, inst;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	unsigned int FindVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name)
+	{
+		//return cscr_readwrite::FindVariableIndexInternal(inst, parentId, name);
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_stringlist.hpp b/src/game/clientscript/cscr_stringlist.hpp
new file mode 100644
index 0000000..8da4e67
--- /dev/null
+++ b/src/game/clientscript/cscr_stringlist.hpp
@@ -0,0 +1,65 @@
+#pragma once
+
+namespace game
+{
+	WEAK symbol<unsigned int(const char* str, scriptInstance_t inst)>SL_FindLowercaseString{ 0x0, 0x68DD50 };
+	WEAK symbol<unsigned int(scriptInstance_t inst, const char* string, unsigned int user, unsigned int len)>SL_GetStringOfSize{ 0x0, 0x68DE50 };
+	WEAK symbol<unsigned int(scriptInstance_t inst, const char* str, unsigned int user, unsigned int len)>SL_GetLowercaseStringOfLen{ 0x0, 0x68E390 };
+	WEAK symbol<unsigned int(scriptInstance_t inst, unsigned int stringVal, unsigned int user)>SL_ConvertToLowercase{ 0x0, 0x68E450 };
+	WEAK symbol<void(scriptInstance_t inst, unsigned int stringValue, RefString* refStr, unsigned int len)>SL_FreeString{ 0x0, 0x68E570 };
+	WEAK symbol<void()>SL_TransferSystem{ 0x0, 0x68E9D0 };
+	WEAK symbol<unsigned int(scriptInstance_t inst, const char* filename)>Scr_CreateCanonicalFilename{ 0x0, 0x68EB00 };
+
+	inline void* SL_ConvertToString_ADDR() { return CALL_ADDR(0x0, 0x68D950); }
+	char* SL_ConvertToString(unsigned int stringValue, scriptInstance_t inst, void* call_addr = SL_ConvertToString_ADDR());
+	inline void* SL_GetStringLen_ADDR() { return CALL_ADDR(0x0, 0x68D970); }
+	int SL_GetStringLen(unsigned int stringValue, scriptInstance_t inst, void* call_addr = SL_GetStringLen_ADDR());
+	inline void* GetHashCode_ADDR() { return CALL_ADDR(0x0, 0x68D9A0); }
+	unsigned int GetHashCode(unsigned int len, const char* str, void* call_addr = GetHashCode_ADDR());
+	inline void* SL_Init_ADDR() { return CALL_ADDR(0x0, 0x68D9F0); }
+	void SL_Init(scriptInstance_t inst, void* call_addr = SL_Init_ADDR());
+	inline void* SL_FindStringOfSize_ADDR() { return CALL_ADDR(0x0, 0x68DA90); }
+	unsigned int SL_FindStringOfSize(scriptInstance_t inst, const char* str, unsigned int len, void* call_addr = SL_FindStringOfSize_ADDR());
+	inline void* SL_FindString_ADDR() { return CALL_ADDR(0x0, 0x68DD20); }
+	unsigned int SL_FindString(const char* str, scriptInstance_t inst, void* call_addr = SL_FindString_ADDR());
+	inline void* SL_AddUserInternal_ADDR() { return CALL_ADDR(0x0, 0x68DDE0); }
+	signed __int32 SL_AddUserInternal(unsigned int user, RefString* refStr, void* call_addr = SL_AddUserInternal_ADDR());
+	inline void* Mark_ScriptStringCustom_ADDR() { return CALL_ADDR(0x0, 0x68DE10); }
+	int Mark_ScriptStringCustom(unsigned int stringValue, void* call_addr = Mark_ScriptStringCustom_ADDR());
+	inline void* SL_GetString__ADDR() { return CALL_ADDR(0x0, 0x68E330); }
+	unsigned int SL_GetString_(const char* str, scriptInstance_t inst, unsigned int user, void* call_addr = SL_GetString__ADDR());
+	inline void* SL_GetString__0_ADDR() { return CALL_ADDR(0x0, 0x68E360); }
+	unsigned int SL_GetString__0(const char* str, unsigned int user, scriptInstance_t inst, void* call_addr = SL_GetString__0_ADDR());
+	inline void* SL_GetLowercaseString_ADDR() { return CALL_ADDR(0x0, 0x68E420); }
+	unsigned int SL_GetLowercaseString(const char* str, void* call_addr = SL_GetLowercaseString_ADDR());
+	inline void* SL_TransferRefToUser_ADDR() { return CALL_ADDR(0x0, 0x68E530); }
+	void SL_TransferRefToUser(unsigned int stringValue, int user, scriptInstance_t inst, void* call_addr = SL_TransferRefToUser_ADDR());
+	inline void* SL_RemoveRefToString_ADDR() { return CALL_ADDR(0x0, 0x68E680); }
+	void SL_RemoveRefToString(unsigned int stringVal, scriptInstance_t inst, void* call_addr = SL_RemoveRefToString_ADDR());
+	inline void* Scr_SetString_ADDR() { return CALL_ADDR(0x0, 0x68E6E0); }
+	void Scr_SetString(scriptInstance_t inst, unsigned int from, unsigned __int16* to, void* call_addr = Scr_SetString_ADDR());
+	inline void* Scr_SetStringFromCharString_ADDR() { return CALL_ADDR(0x0, 0x68E720); }
+	void Scr_SetStringFromCharString(const char* from, unsigned short* to, void* call_addr = Scr_SetStringFromCharString_ADDR());
+	inline void* GScr_AllocString_ADDR() { return CALL_ADDR(0x0, 0x68E770); }
+	unsigned int GScr_AllocString(const char* str, scriptInstance_t inst, void* call_addr = GScr_AllocString_ADDR());
+	inline void* SL_GetStringForFloat_ADDR() { return CALL_ADDR(0x0, 0x68E7A0); }
+	unsigned int SL_GetStringForFloat(float value, scriptInstance_t inst, void* call_addr = SL_GetStringForFloat_ADDR());
+	inline void* SL_GetStringForInt_ADDR() { return CALL_ADDR(0x0, 0x68E800); }
+	unsigned int SL_GetStringForInt(int value, scriptInstance_t inst, void* call_addr = SL_GetStringForInt_ADDR());
+	inline void* SL_GetStringForVector_ADDR() { return CALL_ADDR(0x0, 0x68E850); }
+	unsigned int SL_GetStringForVector(float* value, scriptInstance_t inst, void* call_addr = SL_GetStringForVector_ADDR());
+	inline void* SL_ShutdownSystem_ADDR() { return CALL_ADDR(0x0, 0x68E8D0); }
+	void SL_ShutdownSystem(scriptInstance_t inst, unsigned int user, void* call_addr = SL_ShutdownSystem_ADDR());
+	inline void* SL_CreateCanonicalFilename_ADDR() { return CALL_ADDR(0x0, 0x68EA80); }
+	void SL_CreateCanonicalFilename(const char* filename, char* newFilename, void* call_addr = SL_CreateCanonicalFilename_ADDR());
+
+	RefString* GetRefString(scriptInstance_t inst, unsigned int id);
+	void SL_AddRefToString(scriptInstance_t inst, unsigned int stringValue);
+	void SL_RemoveRefToStringOfSize(scriptInstance_t inst, unsigned int stringValue, unsigned int len);
+	int SL_GetRefStringLen(RefString* refString);
+	void SL_AddUser(unsigned int stringValue, unsigned int user, scriptInstance_t inst);
+	int SL_ConvertFromString(scriptInstance_t inst, const char* str);
+	int SL_ConvertFromRefString(scriptInstance_t inst, RefString* refString);
+	RefString* GetRefString_0(scriptInstance_t inst, const char* str);
+	const char* SL_DebugConvertToString(unsigned int stringValue, scriptInstance_t inst);
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_stringlist_w.cpp b/src/game/clientscript/cscr_stringlist_w.cpp
new file mode 100644
index 0000000..9358456
--- /dev/null
+++ b/src/game/clientscript/cscr_stringlist_w.cpp
@@ -0,0 +1,375 @@
+#include <stdinc.hpp>
+
+namespace game
+{
+	// char *__usercall SL_ConvertToString@<eax>(unsigned int id@<eax>, scriptInstance_t inst@<ecx>)
+	char* SL_ConvertToString(unsigned int id, scriptInstance_t inst, void* call_addr)
+	{
+		char* answer;
+
+		__asm
+		{
+			mov eax, id;
+			mov ecx, inst;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	// int __usercall SL_GetStringLen@<eax>(unsigned int a1@<eax>, scriptInstance_t a2@<ecx>)
+	int SL_GetStringLen(unsigned int a1, scriptInstance_t a2, void* call_addr)
+	{
+		int answer;
+
+		__asm
+		{
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall GetHashCode@<eax>(unsigned int a1@<eax>, char *a2@<edx>)
+	unsigned int GetHashCode(unsigned int a1, const char* a2, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			mov eax, a1;
+			mov edx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	// void __usercall SL_Init(scriptInstance_t a1@<eax>)
+	void SL_Init(scriptInstance_t a1, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+		}
+	}
+
+	// unsigned int __usercall SL_FindStringOfSize@<eax>(scriptInstance_t inst@<eax>, const char *str, unsigned int len)
+	unsigned int SL_FindStringOfSize(scriptInstance_t inst, const char* str_, unsigned int len, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push len;
+			push str_;
+			mov eax, inst;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall SL_FindString@<eax>(char *a1@<edx>, scriptInstance_t a2)
+	unsigned int SL_FindString(const char* a1, scriptInstance_t a2, void* call_addr)
+	{
+#if 0
+	cscr_stringlist::SL_FindString
+#endif
+
+		unsigned int answer;
+
+		__asm
+		{
+			push a2;
+			mov edx, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+
+		return answer;
+	}
+
+	// signed __int32 __usercall SL_AddUserInternal@<eax>(int user@<eax>, volatile signed __int32 *a2@<edx>)
+	signed __int32 SL_AddUserInternal(unsigned int user, RefString* a2, void* call_addr)
+	{
+		signed __int32 answer;
+
+		__asm
+		{
+			mov eax, user;
+			mov edx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	// int __usercall Mark_ScriptStringCustom@<eax>(int a1@<eax>)
+	int Mark_ScriptStringCustom(unsigned int a1, void* call_addr)
+	{
+		int answer;
+
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall SL_GetString_@<eax>(char *a1@<edx>, scriptInstance_t a2, int user)
+	unsigned int SL_GetString_(const char* a1, scriptInstance_t a2, unsigned int user, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push user;
+			push a2;
+			mov edx, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall SL_GetString__0@<eax>(char *a1@<edx>, int user, scriptInstance_t a3)
+	unsigned int SL_GetString__0(const char* a1, unsigned int user, scriptInstance_t a3, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push a3;
+			push user;
+			mov edx, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall SL_GetLowercaseString@<eax>(const char *a2@<edx>)
+	unsigned int SL_GetLowercaseString(const char* a2, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			mov edx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+
+		return answer;
+	}
+
+	// void __usercall SL_TransferRefToUser(unsigned int stringValue@<eax>, int user@<ecx>, scriptInstance_t inst)
+	void SL_TransferRefToUser(unsigned int stringValue, int user, scriptInstance_t inst, void* call_addr)
+	{
+		__asm
+		{
+			push inst;
+			mov eax, stringValue;
+			mov ecx, user;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall SL_RemoveRefToString(unsigned int stringVal@<edx>, scriptInstance_t inst@<esi>)
+	void SL_RemoveRefToString(unsigned int stringVal/*@<edx>*/, scriptInstance_t inst/*@<esi>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov edx, stringVal;
+			mov esi, inst;
+			call call_addr;
+		}
+	}
+
+	// void __usercall Scr_SetString(scriptInstance_t inst@<eax>, unsigned int from@<edi>, unsigned __int16 *to)
+	void Scr_SetString(scriptInstance_t inst, unsigned int from, unsigned __int16* to, void* call_addr)
+	{
+		__asm
+		{
+			push to;
+			mov eax, inst;
+			mov edi, from;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// unsigned int __usercall Scr_SetStringFromCharString@<eax>(char *a1@<edi>, _WORD *a2)
+	void Scr_SetStringFromCharString(const char* a1, unsigned short* a2, void* call_addr)
+	{
+		__asm
+		{
+			push a2;
+			mov edi, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// unsigned int __usercall GScr_AllocString@<eax>(char *a1@<edx>, scriptInstance_t inst)
+	unsigned int GScr_AllocString(const char* a1, scriptInstance_t inst, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push inst;
+			mov edx, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall SL_GetStringForFloat@<eax>(float a1@<xmm0>, scriptInstance_t a2)
+	unsigned int SL_GetStringForFloat(float a1, scriptInstance_t a2, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push a2;
+			movsd xmm0, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall SL_GetStringForInt@<eax>(int a1@<eax>, scriptInstance_t a2)
+	unsigned int SL_GetStringForInt(int a1, scriptInstance_t a2, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push a2;
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall SL_GetStringForVector@<eax>(float *a1@<eax>, scriptInstance_t a2)
+	unsigned int SL_GetStringForVector(float* a1, scriptInstance_t a2, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push a2;
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+
+		return answer;
+	}
+
+	// void __usercall SL_ShutdownSystem(scriptInstance_t a1@<edi>, unsigned int a2)
+	void SL_ShutdownSystem(scriptInstance_t a1, unsigned int a2, void* call_addr)
+	{
+		__asm
+		{
+			push a2;
+			mov edi, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall CreateCanonicalFilename(const char *a1@<eax>, char *a2)
+	void SL_CreateCanonicalFilename(const char* a1, char* a2, void* call_addr)
+	{
+		__asm
+		{
+			push a2;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	RefString* GetRefString(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_stringlist::GetRefString(inst, id);
+		return nullptr;
+	}
+
+	void SL_AddRefToString(scriptInstance_t inst, unsigned int stringValue)
+	{
+		//cscr_stringlist::SL_AddRefToString(inst, stringValue);
+	}
+
+	void SL_RemoveRefToStringOfSize(scriptInstance_t inst, unsigned int stringValue, unsigned int len)
+	{
+		//cscr_stringlist::SL_RemoveRefToStringOfSize(inst, stringValue, len);
+	}
+
+	int SL_GetRefStringLen(RefString* refString)
+	{
+		//return cscr_stringlist::SL_GetRefStringLen(refString);
+		return 0;
+	}
+
+	void SL_AddUser(unsigned int stringValue, unsigned int user, scriptInstance_t inst)
+	{
+		//cscr_stringlist::SL_AddUser(stringValue, user, inst);
+	}
+
+	int SL_ConvertFromString(scriptInstance_t inst, const char* str)
+	{
+		//return cscr_stringlist::SL_ConvertFromString(inst, str);
+		return 0;
+	}
+
+	int SL_ConvertFromRefString(scriptInstance_t inst, RefString* refString)
+	{
+		//return cscr_stringlist::SL_ConvertFromRefString(inst, refString);
+		return 0;
+	}
+
+	RefString* GetRefString_0(scriptInstance_t inst, const char* str)
+	{
+		//return cscr_stringlist::GetRefString_0(inst, str);
+		return nullptr;
+	}
+
+	const char* SL_DebugConvertToString(unsigned int stringValue, scriptInstance_t inst)
+	{
+		//return cscr_stringlist::SL_DebugConvertToString(stringValue, inst);
+		return nullptr;
+	}
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_tempmemory.hpp b/src/game/clientscript/cscr_tempmemory.hpp
new file mode 100644
index 0000000..7303aa3
--- /dev/null
+++ b/src/game/clientscript/cscr_tempmemory.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+namespace game
+{
+	void TempMemorySetPos(char* pos);
+	void TempMemoryReset(HunkUser* user);
+	char* TempMalloc(int len);
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_tempmemory_w.cpp b/src/game/clientscript/cscr_tempmemory_w.cpp
new file mode 100644
index 0000000..3eb12a8
--- /dev/null
+++ b/src/game/clientscript/cscr_tempmemory_w.cpp
@@ -0,0 +1,20 @@
+#include <stdinc.hpp>
+
+namespace game
+{
+	void TempMemorySetPos(char* pos)
+	{
+		//cscr_tempmemory::TempMemorySetPos(pos);
+	}
+
+	void TempMemoryReset(HunkUser* user)
+	{
+		//cscr_tempmemory::TempMemoryReset(user);
+	}
+
+	char* TempMalloc(int len)
+	{
+		//return cscr_tempmemory::TempMalloc(len);
+		return nullptr;
+	}
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_variable.hpp b/src/game/clientscript/cscr_variable.hpp
new file mode 100644
index 0000000..6f7222a
--- /dev/null
+++ b/src/game/clientscript/cscr_variable.hpp
@@ -0,0 +1,229 @@
+#pragma once
+
+namespace game
+{
+	WEAK symbol<int(const void * info1, const void * info2)>ThreadInfoCompare{ 0x0, 0x68EB50};
+	WEAK symbol<void(scriptInstance_t scriptInstance)>Scr_DumpScriptThreads{ 0x0, 0x68EBA0};
+	WEAK symbol<unsigned int(scriptInstance_t inst, unsigned int parentId, unsigned int name, unsigned int index)>GetNewVariableIndexInternal3{ 0x0, 0x68F090};
+	WEAK symbol<void(scriptInstance_t inst, unsigned int parentId)>ClearObjectInternal{ 0x0, 0x68F910};
+	WEAK symbol<void(scriptInstance_t inst, VariableType type, VariableUnion a3)>RemoveRefToValueInternal{ 0x0, 0x6901C0};
+	WEAK symbol<void(scriptInstance_t inst, unsigned int parentId, unsigned int newParentId)>CopyArray{ 0x0, 0x690770};
+	WEAK symbol<void(scriptInstance_t inst, unsigned int parentId, unsigned int name, VariableValue * value)>SetVariableEntityFieldValue{ 0x0, 0x690910};
+	WEAK symbol<void(scriptInstance_t inst, VariableValue * a2)>Scr_ClearVector{ 0x0, 0x691000};
+	WEAK symbol<void(scriptInstance_t inst)>Scr_FreeEntityList{ 0x0, 0x692160};
+	WEAK symbol<void(scriptInstance_t inst)>Scr_FreeObjects{ 0x0, 0x6921E0};
+	WEAK symbol<void(unsigned int arrayId, scriptInstance_t inst)>Scr_AddArrayKeys{ 0x0, 0x692DE0};
+	WEAK symbol<float(scriptInstance_t inst, unsigned int parentId)>Scr_GetObjectUsage{ 0x0, 0x693030};
+	WEAK symbol<char *(const char * filename)>Scr_GetSourceFile_LoadObj{ 0x0, 0x6932C0};
+	WEAK symbol<char *(const char * filename)>Scr_GetSourceFile_FastFile{ 0x0, 0x693350};
+	WEAK symbol<void(scriptInstance_t inst, char * Format)>Scr_AddFieldsForFile{ 0x0, 0x693390};
+	WEAK symbol<void(scriptInstance_t inst, const char * path, const char * extension)>Scr_AddFields_LoadObj{ 0x0, 0x6936B0};
+	WEAK symbol<void(scriptInstance_t inst, const char * path, const char * extension)>Scr_AddFields_FastFile{ 0x0, 0x693830};
+	WEAK symbol<int(scriptInstance_t inst, unsigned int parentId)>Scr_MakeValuePrimitive{ 0x0, 0x6938B0};
+
+	inline void* Scr_InitVariableRange_ADDR() { return CALL_ADDR(0x0, 0x68EF90); }
+	void Scr_InitVariableRange(unsigned int begin, unsigned int end, scriptInstance_t inst, void* call_addr = Scr_InitVariableRange_ADDR());
+	inline void* Scr_InitClassMap_ADDR() { return CALL_ADDR(0x0, 0x68F030); }
+	void Scr_InitClassMap(scriptInstance_t inst, void* call_addr = Scr_InitClassMap_ADDR());
+	inline void* GetNewVariableIndexInternal2_ADDR() { return CALL_ADDR(0x0, 0x68F4A0); }
+	unsigned int GetNewVariableIndexInternal2(unsigned int name, scriptInstance_t inst, unsigned int parentId, unsigned int index, void* call_addr = GetNewVariableIndexInternal2_ADDR());
+	inline void* GetNewVariableIndexReverseInternal2_ADDR() { return CALL_ADDR(0x0, 0x68F560); }
+	unsigned int GetNewVariableIndexReverseInternal2(unsigned int name, scriptInstance_t inst, unsigned int parentId, unsigned int index, void* call_addr = GetNewVariableIndexReverseInternal2_ADDR());
+	inline void* MakeVariableExternal_ADDR() { return CALL_ADDR(0x0, 0x68F620); }
+	void MakeVariableExternal(VariableValueInternal * parentValue, scriptInstance_t inst, unsigned int index, void* call_addr = MakeVariableExternal_ADDR());
+	inline void* FreeChildValue_ADDR() { return CALL_ADDR(0x0, 0x68F800); }
+	void FreeChildValue(unsigned int id, scriptInstance_t inst, unsigned int parentId, void* call_addr = FreeChildValue_ADDR());
+	inline void* ClearObject_ADDR() { return CALL_ADDR(0x0, 0x68F9E0); }
+	void ClearObject(unsigned int parentId, scriptInstance_t inst, void* call_addr = ClearObject_ADDR());
+	inline void* Scr_StopThread_ADDR() { return CALL_ADDR(0x0, 0x68FA30); }
+	void Scr_StopThread(scriptInstance_t inst, unsigned int threadId, void* call_addr = Scr_StopThread_ADDR());
+	inline void* GetSafeParentLocalId_ADDR() { return CALL_ADDR(0x0, 0x68FAA0); }
+	unsigned int GetSafeParentLocalId(scriptInstance_t inst, unsigned int threadId, void* call_addr = GetSafeParentLocalId_ADDR());
+	inline void* GetStartLocalId_ADDR() { return CALL_ADDR(0x0, 0x68FAD0); }
+	unsigned int GetStartLocalId(unsigned int threadId, scriptInstance_t inst, void* call_addr = GetStartLocalId_ADDR());
+	inline void* Scr_KillThread_ADDR() { return CALL_ADDR(0x0, 0x68FB10); }
+	void Scr_KillThread(scriptInstance_t inst, unsigned int parentId, void* call_addr = Scr_KillThread_ADDR());
+	inline void* AllocVariable_ADDR() { return CALL_ADDR(0x0, 0x68FCE0); }
+	unsigned __int16 AllocVariable(scriptInstance_t inst, void* call_addr = AllocVariable_ADDR());
+	inline void* FreeVariable_ADDR() { return CALL_ADDR(0x0, 0x68FDC0); }
+	void FreeVariable(unsigned int id, scriptInstance_t inst, void* call_addr = FreeVariable_ADDR());
+	inline void* AllocValue_ADDR() { return CALL_ADDR(0x0, 0x68FE20); }
+	unsigned int AllocValue(scriptInstance_t inst, void* call_addr = AllocValue_ADDR());
+	inline void* AllocEntity_ADDR() { return CALL_ADDR(0x0, 0x68FF10); }
+	unsigned int AllocEntity(unsigned int classnum, scriptInstance_t inst, int entnum, int clientnum, void* call_addr = AllocEntity_ADDR());
+	inline void* Scr_AllocArray_ADDR() { return CALL_ADDR(0x0, 0x68FF60); }
+	unsigned int Scr_AllocArray(scriptInstance_t inst, void* call_addr = Scr_AllocArray_ADDR());
+	inline void* AllocChildThread_ADDR() { return CALL_ADDR(0x0, 0x68FF90); }
+	unsigned int AllocChildThread(scriptInstance_t inst, unsigned int parentLocalId, unsigned int self, void* call_addr = AllocChildThread_ADDR());
+	inline void* FreeValue_ADDR() { return CALL_ADDR(0x0, 0x68FFD0); }
+	void FreeValue(unsigned int id, scriptInstance_t inst, void* call_addr = FreeValue_ADDR());
+	inline void* RemoveRefToObject_ADDR() { return CALL_ADDR(0x0, 0x690040); }
+	void RemoveRefToObject(unsigned int id, scriptInstance_t inst, void* call_addr = RemoveRefToObject_ADDR());
+	inline void* Scr_AllocVector_ADDR() { return CALL_ADDR(0x0, 0x690100); }
+	float * Scr_AllocVector(scriptInstance_t inst, void* call_addr = Scr_AllocVector_ADDR());
+	inline void* RemoveRefToVector_ADDR() { return CALL_ADDR(0x0, 0x690130); }
+	void RemoveRefToVector(const float* vectorValue, scriptInstance_t inst, void* call_addr = RemoveRefToVector_ADDR());
+	inline void* AddRefToValue_ADDR() { return CALL_ADDR(0x0, 0x690160); }
+	void AddRefToValue(scriptInstance_t inst, VariableType type_, VariableUnion u, void* call_addr = AddRefToValue_ADDR());
+	inline void* FindArrayVariable_ADDR() { return CALL_ADDR(0x0, 0x690210); }
+	int FindArrayVariable(unsigned int id, unsigned int intvalue, scriptInstance_t inst, void* call_addr = FindArrayVariable_ADDR());
+	inline void* FindVariable_ADDR() { return CALL_ADDR(0x0, 0x690260); }
+	unsigned int FindVariable(unsigned int unsignedValue, unsigned int parentId, scriptInstance_t inst, void* call_addr = FindVariable_ADDR());
+	inline void* GetArrayVariableIndex_ADDR() { return CALL_ADDR(0x0, 0x6902A0); }
+	unsigned int GetArrayVariableIndex(unsigned int unsignedValue, scriptInstance_t inst, unsigned int parentId, void* call_addr = GetArrayVariableIndex_ADDR());
+	inline void* Scr_GetVariableFieldIndex_ADDR() { return CALL_ADDR(0x0, 0x6902F0); }
+	unsigned int Scr_GetVariableFieldIndex(scriptInstance_t inst, unsigned int name, unsigned int parentId, void* call_addr = Scr_GetVariableFieldIndex_ADDR());
+	inline void* Scr_FindVariableField_ADDR() { return CALL_ADDR(0x0, 0x6903B0); }
+	VariableValue Scr_FindVariableField(scriptInstance_t inst, unsigned int parentId, unsigned int name, void* call_addr = Scr_FindVariableField_ADDR());
+	inline void* ClearVariableField_ADDR() { return CALL_ADDR(0x0, 0x690450); }
+	void ClearVariableField(scriptInstance_t inst, unsigned int id, unsigned int name, VariableValue * value, void* call_addr = ClearVariableField_ADDR());
+	inline void* GetVariable_ADDR() { return CALL_ADDR(0x0, 0x690510); }
+	unsigned int GetVariable(scriptInstance_t inst, unsigned int parentId, unsigned int name, void* call_addr = GetVariable_ADDR());
+	inline void* GetNewVariable_ADDR() { return CALL_ADDR(0x0, 0x690570); }
+	unsigned int GetNewVariable(scriptInstance_t inst, unsigned int unsignedValue, unsigned int parentId, void* call_addr = GetNewVariable_ADDR());
+	inline void* GetObjectVariable_ADDR() { return CALL_ADDR(0x0, 0x6905B0); }
+	unsigned int GetObjectVariable(unsigned int id, scriptInstance_t inst, unsigned int parentId, void* call_addr = GetObjectVariable_ADDR());
+	inline void* GetNewObjectVariable_ADDR() { return CALL_ADDR(0x0, 0x690610); }
+	unsigned int GetNewObjectVariable(scriptInstance_t inst, unsigned int name, unsigned int parentId, void* call_addr = GetNewObjectVariable_ADDR());
+	inline void* RemoveVariable_ADDR() { return CALL_ADDR(0x0, 0x690650); }
+	void RemoveVariable(unsigned int name, unsigned int parentId, scriptInstance_t inst, void* call_addr = RemoveVariable_ADDR());
+	inline void* RemoveNextVariable_ADDR() { return CALL_ADDR(0x0, 0x6906A0); }
+	void RemoveNextVariable(scriptInstance_t inst, unsigned int parentId, void* call_addr = RemoveNextVariable_ADDR());
+	inline void* SafeRemoveVariable_ADDR() { return CALL_ADDR(0x0, 0x690710); }
+	void SafeRemoveVariable(unsigned int unsignedValue, unsigned int parentId, scriptInstance_t inst, void* call_addr = SafeRemoveVariable_ADDR());
+	inline void* SetVariableValue_ADDR() { return CALL_ADDR(0x0, 0x6908D0); }
+	void SetVariableValue(scriptInstance_t inst, VariableValue * value, unsigned int id, void* call_addr = SetVariableValue_ADDR());
+	inline void* Scr_EvalVariable_ADDR() { return CALL_ADDR(0x0, 0x690A10); }
+	VariableValue Scr_EvalVariable(scriptInstance_t inst, unsigned int id, void* call_addr = Scr_EvalVariable_ADDR());
+	inline void* Scr_EvalVariableObject_ADDR() { return CALL_ADDR(0x0, 0x690A50); }
+	unsigned int Scr_EvalVariableObject(scriptInstance_t inst, int id, void* call_addr = Scr_EvalVariableObject_ADDR());
+	inline void* Scr_EvalVariableEntityField_ADDR() { return CALL_ADDR(0x0, 0x690AB0); }
+	VariableValue Scr_EvalVariableEntityField(unsigned int entId, scriptInstance_t inst, unsigned int name, void* call_addr = Scr_EvalVariableEntityField_ADDR());
+	inline void* Scr_EvalVariableField_ADDR() { return CALL_ADDR(0x0, 0x690BB0); }
+	VariableValue Scr_EvalVariableField(scriptInstance_t inst, unsigned int id, void* call_addr = Scr_EvalVariableField_ADDR());
+	inline void* Scr_EvalSizeValue_ADDR() { return CALL_ADDR(0x0, 0x690C10); }
+	void Scr_EvalSizeValue(scriptInstance_t inst, VariableValue * value, void* call_addr = Scr_EvalSizeValue_ADDR());
+	inline void* GetObject_ADDR() { return CALL_ADDR(0x0, 0x690CF0); }
+	unsigned int GetObject(scriptInstance_t inst, unsigned int id, void* call_addr = GetObject_ADDR());
+	inline void* GetArray_ADDR() { return CALL_ADDR(0x0, 0x690D50); }
+	unsigned int GetArray(scriptInstance_t inst, unsigned int id, void* call_addr = GetArray_ADDR());
+	inline void* Scr_EvalBoolComplement_ADDR() { return CALL_ADDR(0x0, 0x690DB0); }
+	void Scr_EvalBoolComplement(scriptInstance_t inst, VariableValue * value, void* call_addr = Scr_EvalBoolComplement_ADDR());
+	inline void* Scr_CastBool_ADDR() { return CALL_ADDR(0x0, 0x690E00); }
+	void Scr_CastBool(scriptInstance_t inst, VariableValue* value, void* call_addr = Scr_CastBool_ADDR());
+	inline void* Scr_CastString_ADDR() { return CALL_ADDR(0x0, 0x690E80); }
+	char Scr_CastString(scriptInstance_t inst, VariableValue* value, void* call_addr = Scr_CastString_ADDR());
+	inline void* Scr_CastDebugString_ADDR() { return CALL_ADDR(0x0, 0x690F30); }
+	void Scr_CastDebugString(scriptInstance_t inst, VariableValue* value, void* call_addr = Scr_CastDebugString_ADDR());
+	inline void* Scr_CastVector_ADDR() { return CALL_ADDR(0x0, 0x691040); }
+	void Scr_CastVector(scriptInstance_t inst, VariableValue* value, void* call_addr = Scr_CastVector_ADDR());
+	inline void* Scr_EvalFieldObject_ADDR() { return CALL_ADDR(0x0, 0x691110); }
+	VariableUnion Scr_EvalFieldObject(VariableValue * value, scriptInstance_t inst, int a3, void* call_addr = Scr_EvalFieldObject_ADDR());
+	inline void* Scr_UnmatchingTypesError_ADDR() { return CALL_ADDR(0x0, 0x6911B0); }
+	void Scr_UnmatchingTypesError(scriptInstance_t inst, VariableValue * value2, VariableValue * value1, void* call_addr = Scr_UnmatchingTypesError_ADDR());
+	inline void* Scr_CastWeakerPair_ADDR() { return CALL_ADDR(0x0, 0x691270); }
+	void Scr_CastWeakerPair(VariableValue * value2, VariableValue * value1, scriptInstance_t inst, void* call_addr = Scr_CastWeakerPair_ADDR());
+	inline void* Scr_CastWeakerStringPair_ADDR() { return CALL_ADDR(0x0, 0x691370); }
+	void Scr_CastWeakerStringPair(VariableValue * value2, VariableValue * value1, scriptInstance_t inst, void* call_addr = Scr_CastWeakerStringPair_ADDR());
+	inline void* Scr_EvalOr_ADDR() { return CALL_ADDR(0x0, 0x6914E0); }
+	void Scr_EvalOr(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalOr_ADDR());
+	inline void* Scr_EvalExOr_ADDR() { return CALL_ADDR(0x0, 0x691510); }
+	void Scr_EvalExOr(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalExOr_ADDR());
+	inline void* Scr_EvalAnd_ADDR() { return CALL_ADDR(0x0, 0x691540); }
+	void Scr_EvalAnd(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalAnd_ADDR());
+	inline void* Scr_EvalEquality_ADDR() { return CALL_ADDR(0x0, 0x691570); }
+	void Scr_EvalEquality(VariableValue * value1, scriptInstance_t inst, VariableValue * value2, void* call_addr = Scr_EvalEquality_ADDR());
+	inline void* Scr_EvalLess_ADDR() { return CALL_ADDR(0x0, 0x691760); }
+	void Scr_EvalLess(VariableValue * value1, VariableValue * value2, scriptInstance_t a3, void* call_addr = Scr_EvalLess_ADDR());
+	inline void* Scr_EvalGreaterEqual_ADDR() { return CALL_ADDR(0x0, 0x6917D0); }
+	void Scr_EvalGreaterEqual(scriptInstance_t inst, VariableValue * value1, VariableValue * value2, void* call_addr = Scr_EvalGreaterEqual_ADDR());
+	inline void* Scr_EvalGreater_ADDR() { return CALL_ADDR(0x0, 0x6917F0); }
+	void Scr_EvalGreater(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalGreater_ADDR());
+	inline void* Scr_EvalLessEqual_ADDR() { return CALL_ADDR(0x0, 0x691860); }
+	void Scr_EvalLessEqual(scriptInstance_t inst, VariableValue * value1, VariableValue * value2, void* call_addr = Scr_EvalLessEqual_ADDR());
+	inline void* Scr_EvalShiftLeft_ADDR() { return CALL_ADDR(0x0, 0x691880); }
+	void Scr_EvalShiftLeft(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalShiftLeft_ADDR());
+	inline void* Scr_EvalShiftRight_ADDR() { return CALL_ADDR(0x0, 0x6918B0); }
+	void Scr_EvalShiftRight(VariableValue * value1, VariableValue * value2, scriptInstance_t inst, void* call_addr = Scr_EvalShiftRight_ADDR());
+	inline void* Scr_EvalPlus_ADDR() { return CALL_ADDR(0x0, 0x6918E0); }
+	void Scr_EvalPlus(scriptInstance_t inst, VariableValue* value1, VariableValue* value2, void* call_addr = Scr_EvalPlus_ADDR());
+	inline void* Scr_EvalMinus_ADDR() { return CALL_ADDR(0x0, 0x691B00); }
+	void Scr_EvalMinus(VariableValue * value1, scriptInstance_t inst, VariableValue * value2, void* call_addr = Scr_EvalMinus_ADDR());
+	inline void* Scr_EvalMultiply_ADDR() { return CALL_ADDR(0x0, 0x691C20); }
+	void Scr_EvalMultiply(VariableValue * value1, scriptInstance_t inst, VariableValue * value2, void* call_addr = Scr_EvalMultiply_ADDR());
+	inline void* Scr_EvalDivide_ADDR() { return CALL_ADDR(0x0, 0x691D40); }
+	void Scr_EvalDivide(VariableValue * value1, scriptInstance_t inst, VariableValue * value2, void* call_addr = Scr_EvalDivide_ADDR());
+	inline void* Scr_EvalMod_ADDR() { return CALL_ADDR(0x0, 0x691F00); }
+	void Scr_EvalMod(scriptInstance_t inst, VariableValue * value1, VariableValue * value2, void* call_addr = Scr_EvalMod_ADDR());
+	inline void* Scr_EvalBinaryOperator_ADDR() { return CALL_ADDR(0x0, 0x691F50); }
+	void Scr_EvalBinaryOperator(scriptInstance_t inst, VariableValue * value1, OpcodeVM op, VariableValue * value2, void* call_addr = Scr_EvalBinaryOperator_ADDR());
+	inline void* Scr_FreeEntityNum_ADDR() { return CALL_ADDR(0x0, 0x692090); }
+	void Scr_FreeEntityNum(scriptInstance_t inst, unsigned int result, unsigned int entnum, void* call_addr = Scr_FreeEntityNum_ADDR());
+	inline void* Scr_SetClassMap_ADDR() { return CALL_ADDR(0x0, 0x692260); }
+	void Scr_SetClassMap(scriptInstance_t inst, unsigned int classnum, void* call_addr = Scr_SetClassMap_ADDR());
+	inline void* Scr_RemoveClassMap_ADDR() { return CALL_ADDR(0x0, 0x6922E0); }
+	void Scr_RemoveClassMap(unsigned int classnum, scriptInstance_t inst, void* call_addr = Scr_RemoveClassMap_ADDR());
+	inline void* Scr_AddClassField_ADDR() { return CALL_ADDR(0x0, 0x692350); }
+	void Scr_AddClassField(scriptInstance_t inst, unsigned int classnum, const char * name, unsigned int offset, void* call_addr = Scr_AddClassField_ADDR());
+	inline void* Scr_GetOffset_ADDR() { return CALL_ADDR(0x0, 0x692440); }
+	VariableUnion Scr_GetOffset(const char * name, scriptInstance_t inst, classNum_e classNum, void* call_addr = Scr_GetOffset_ADDR());
+	inline void* FindEntityId_ADDR() { return CALL_ADDR(0x0, 0x6924C0); }
+	unsigned int FindEntityId(unsigned int entClass, int entNum, scriptInstance_t inst, void* call_addr = FindEntityId_ADDR());
+	inline void* Scr_GetEntityId_ADDR() { return CALL_ADDR(0x0, 0x692520); }
+	unsigned int Scr_GetEntityId(int entNum, scriptInstance_t inst, classNum_e classnum, int clientnum, void* call_addr = Scr_GetEntityId_ADDR());
+	inline void* Scr_FindArrayIndex_ADDR() { return CALL_ADDR(0x0, 0x6925B0); }
+	unsigned int Scr_FindArrayIndex(scriptInstance_t inst, VariableValue* index, unsigned int parentId, void* call_addr = Scr_FindArrayIndex_ADDR());
+	inline void* Scr_EvalArray_ADDR() { return CALL_ADDR(0x0, 0x692680); }
+	void Scr_EvalArray(scriptInstance_t inst, VariableValue * index, VariableValue * value, void* call_addr = Scr_EvalArray_ADDR());
+	inline void* Scr_EvalArrayRef_ADDR() { return CALL_ADDR(0x0, 0x692850); }
+	unsigned int Scr_EvalArrayRef(scriptInstance_t inst, unsigned int parentId, void* call_addr = Scr_EvalArrayRef_ADDR());
+	inline void* ClearArray_ADDR() { return CALL_ADDR(0x0, 0x692AF0); }
+	void ClearArray(unsigned int parentId, scriptInstance_t inst, VariableValue * value, void* call_addr = ClearArray_ADDR());
+	inline void* SetEmptyArray_ADDR() { return CALL_ADDR(0x0, 0x692D70); }
+	void SetEmptyArray(scriptInstance_t inst, unsigned int parentId, void* call_addr = SetEmptyArray_ADDR());
+	inline void* Scr_GetEntityIdRef_ADDR() { return CALL_ADDR(0x0, 0x692EC0); }
+	scr_entref_t * Scr_GetEntityIdRef(scr_entref_t * retstr, scriptInstance_t inst, unsigned int entId, void* call_addr = Scr_GetEntityIdRef_ADDR());
+	inline void* CopyEntity_ADDR() { return CALL_ADDR(0x0, 0x692F00); }
+	void CopyEntity(unsigned int parentId, unsigned int newParentId, void* call_addr = CopyEntity_ADDR());
+	inline void* Scr_GetEndonUsage_ADDR() { return CALL_ADDR(0x0, 0x692FC0); }
+	float Scr_GetEndonUsage(unsigned int parentId, scriptInstance_t inst, void* call_addr = Scr_GetEndonUsage_ADDR());
+	inline void* Scr_GetThreadUsage_ADDR() { return CALL_ADDR(0x0, 0x693130); }
+	float Scr_GetThreadUsage(VariableStackBuffer * stackBuf, scriptInstance_t inst, float * endonUsage, void* call_addr = Scr_GetThreadUsage_ADDR());
+	inline void* Scr_FindField_ADDR() { return CALL_ADDR(0x0, 0x693250); }
+	unsigned int Scr_FindField(scriptInstance_t inst, const char * name, int * type, void* call_addr = Scr_FindField_ADDR());
+	inline void* Scr_FreeGameVariable_ADDR() { return CALL_ADDR(0x0, 0x693A10); }
+	void Scr_FreeGameVariable(scriptInstance_t inst, int bComplete, void* call_addr = Scr_FreeGameVariable_ADDR());
+	inline void* Scr_SLHasLowercaseString_ADDR() { return CALL_ADDR(0x0, 0x693A70); }
+	bool Scr_SLHasLowercaseString(unsigned int parentId, const char * str, void* call_addr = Scr_SLHasLowercaseString_ADDR());
+
+	unsigned int FindObject(scriptInstance_t inst, unsigned int id);
+	unsigned int FindFirstSibling(scriptInstance_t inst, unsigned int id);
+	unsigned int FindNextSibling(scriptInstance_t inst, unsigned int id);
+	VariableValue Scr_GetArrayIndexValue(scriptInstance_t inst, unsigned int name);
+	float Scr_GetEntryUsageInternal(scriptInstance_t inst, unsigned int type, VariableUnion u);
+	float Scr_GetEntryUsage(scriptInstance_t inst, VariableValueInternal* entryValue);
+	void AddRefToObject(scriptInstance_t inst, unsigned int id);
+	void RemoveRefToEmptyObject(scriptInstance_t inst, unsigned int id);
+	void Scr_ClearThread(scriptInstance_t inst, unsigned int parentId);
+	unsigned int FindObjectVariable(scriptInstance_t inst, unsigned int parentId, unsigned int id);
+	void RemoveObjectVariable(scriptInstance_t inst, unsigned int parentId, unsigned int id);
+	VariableValueInternal_u* GetVariableValueAddress(scriptInstance_t inst, unsigned int id);
+	void Scr_KillEndonThread(scriptInstance_t inst, unsigned int threadId);
+	BOOL IsValidArrayIndex(scriptInstance_t inst, unsigned int unsignedValue);
+	void RemoveArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	void SafeRemoveArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	void AddRefToVector(scriptInstance_t inst, const float* floatVal);
+	unsigned int FindArrayVariableIndex(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	unsigned int GetVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name);
+	unsigned int GetNewVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name);
+	unsigned int AllocObject(scriptInstance_t inst);
+	VariableType GetValueType(scriptInstance_t inst, unsigned int id);
+	VariableType GetObjectType(scriptInstance_t inst, unsigned int id);
+	float* Scr_AllocVector_(scriptInstance_t inst, const float* v);
+	void Scr_EvalInequality(scriptInstance_t inst, VariableValue* value1, VariableValue* value2);
+	unsigned int Scr_EvalArrayRefInternal(scriptInstance_t inst, VariableValue* varValue, VariableValueInternal* parentValue);
+	unsigned int GetNewArrayVariableIndex(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	unsigned int GetNewArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	unsigned int GetArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue);
+	unsigned int AllocThread(scriptInstance_t inst, unsigned int self);
+}
diff --git a/src/game/clientscript/cscr_variable_w.cpp b/src/game/clientscript/cscr_variable_w.cpp
new file mode 100644
index 0000000..6f8e5c6
--- /dev/null
+++ b/src/game/clientscript/cscr_variable_w.cpp
@@ -0,0 +1,1459 @@
+#include <stdinc.hpp>
+
+namespace game
+{
+	// void __usercall Scr_InitVariableRange(unsigned int a1@<edi>, unsigned int a2@<esi>, scriptInstance_t a3)
+	void Scr_InitVariableRange(unsigned int a1, unsigned int a2, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov edi, a1;
+			mov esi, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_InitClassMap(scriptInstance_t a1@<eax>)
+	void Scr_InitClassMap(scriptInstance_t a1, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+		}
+	}
+
+	// unsigned int __usercall GetNewVariableIndexInternal2@<eax>(unsigned int name@<ecx>, scriptInstance_t inst, unsigned int parentId, unsigned int index)
+	unsigned int GetNewVariableIndexInternal2(unsigned int name, scriptInstance_t inst, unsigned int parentId, unsigned int index, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push index;
+			push parentId;
+			push inst;
+			mov ecx, name;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0xC;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall GetNewVariableIndexReverseInternal2@<eax>(unsigned int name@<ecx>, scriptInstance_t inst, unsigned int parentId, unsigned int index)
+	unsigned int GetNewVariableIndexReverseInternal2(unsigned int name, scriptInstance_t inst, unsigned int parentId, unsigned int index, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push index;
+			push parentId;
+			push inst;
+			mov ecx, name;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0xC;
+		}
+
+		return answer;
+	}
+
+	// void __usercall MakeVariableExternal(VariableValueInternal *parentValue@<eax>, scriptInstance_t inst, unsigned int index)
+	void MakeVariableExternal(VariableValueInternal* parentValue, scriptInstance_t inst, unsigned int index, void* call_addr)
+	{
+		__asm
+		{
+			push index;
+			push inst;
+			mov eax, parentValue;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// void __usercall FreeChildValue(unsigned int id@<eax>, scriptInstance_t inst, unsigned int parentId)
+	void FreeChildValue(unsigned int id, scriptInstance_t inst, unsigned int parentId, void* call_addr)
+	{
+		__asm
+		{
+			push parentId;
+			push inst;
+			mov eax, id;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// void __usercall ClearObject(unsigned int a1@<edi>, scriptInstance_t a2)
+	void ClearObject(unsigned int a1, scriptInstance_t a2, void* call_addr)
+	{
+		__asm
+		{
+			push a2;
+			mov edi, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_StopThread(scriptInstance_t inst@<ecx>, unsigned int a2@<eax>)
+	void Scr_StopThread(scriptInstance_t inst, unsigned int a2, void* call_addr)
+	{
+		__asm
+		{
+			mov ecx, inst;
+			mov eax, a2;
+			call call_addr;
+		}
+	}
+
+	// unsigned int __usercall GetSafeParentLocalId@<eax>(scriptInstance_t a1@<eax>, unsigned int a2)
+	unsigned int GetSafeParentLocalId(scriptInstance_t a1, unsigned int a2, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push a2;
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall GetStartLocalId@<eax>(unsigned int result@<eax>, scriptInstance_t a2@<ecx>)
+	unsigned int GetStartLocalId(unsigned int result, scriptInstance_t a2, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, result;
+			mov ecx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall Scr_KillThread(scriptInstance_t inst@<ecx>, unsigned int parentId_1@<eax>)
+	void Scr_KillThread(scriptInstance_t inst, unsigned int parentId_1, void* call_addr)
+	{
+		__asm
+		{
+			mov ecx, inst;
+			mov eax, parentId_1;
+			call call_addr;
+		}
+	}
+
+	// unsigned __int16 __usercall AllocVariable@<ax>(scriptInstance_t inst@<eax>)
+	unsigned __int16 AllocVariable(scriptInstance_t inst, void* call_addr)
+	{
+		unsigned __int16 answer;
+		
+		__asm
+		{
+			mov eax, inst;
+			call call_addr;
+			mov answer, ax;
+		}
+		
+		return answer;
+	}
+
+	// int __usercall FreeVariable@<eax>(int a1@<eax>, scriptInstance_t a2@<edx>)
+	void FreeVariable(unsigned int a1, scriptInstance_t a2, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			mov edx, a2;
+			call call_addr;
+		}
+	}
+
+	// unsigned int __usercall AllocValue@<eax>(scriptInstance_t inst@<eax>)
+	unsigned int AllocValue(scriptInstance_t inst, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, inst;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall AllocEntity@<eax>(unsigned int classnum@<eax>, scriptInstance_t inst@<ecx>, int entnum, int clientnum)
+	unsigned int AllocEntity(unsigned int classnum, scriptInstance_t inst, int entnum, int clientnum, void* call_addr)
+	{
+		unsigned int answer;
+
+		__asm
+		{
+			push clientnum;
+			push entnum;
+			mov eax, classnum;
+			mov ecx, inst;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+
+		return answer;
+	}
+
+	// unsigned int __usercall Scr_AllocArray@<eax>(scriptInstance_t a1@<eax>)
+	unsigned int Scr_AllocArray(scriptInstance_t a1, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall AllocChildThread@<eax>(scriptInstance_t inst@<ecx>, unsigned int a2@<eax>, unsigned int a3)
+	unsigned int AllocChildThread(scriptInstance_t inst, unsigned int a2, unsigned int a3, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			push a3;
+			mov ecx, inst;
+			mov eax, a2;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall FreeValue(unsigned int id@<eax>, scriptInstance_t inst)
+	void FreeValue(unsigned int id, scriptInstance_t inst, void* call_addr)
+	{
+		__asm
+		{
+			push inst;
+			mov eax, id;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall RemoveRefToObject(unsigned int id@<eax>, scriptInstance_t inst@<ecx>)
+	void RemoveRefToObject(unsigned int id, scriptInstance_t inst, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, id;
+			mov ecx, inst;
+			call call_addr;
+		}
+	}
+
+	// float *__usercall Scr_AllocVector@<eax>(scriptInstance_t a1@<eax>)
+	float * Scr_AllocVector(scriptInstance_t a1, void* call_addr)
+	{
+		float * answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall RemoveRefToVector(int vecVal@<eax>, scriptInstance_t inst)
+	void RemoveRefToVector(const float* vecVal, scriptInstance_t inst, void* call_addr)
+	{
+		__asm
+		{
+			push inst;
+			mov eax, vecVal;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall AddRefToValue(scriptInstance_t inst@<eax>, VariableType type@<ecx>, VariableUnion u)
+	void AddRefToValue(scriptInstance_t inst, VariableType type_, VariableUnion u, void* call_addr)
+	{
+		__asm
+		{
+			push u;
+			mov eax, inst;
+			mov ecx, type_;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// int __usercall FindArrayVariable@<eax>(unsigned int id@<eax>, unsigned int intvalue@<ecx>, scriptInstance_t inst)
+	int FindArrayVariable(unsigned int id, unsigned int intvalue, scriptInstance_t inst, void* call_addr)
+	{
+		int answer;
+		
+		__asm
+		{
+			push inst;
+			mov eax, id;
+			mov ecx, intvalue;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+		
+		return answer;
+	}
+
+	// int __usercall FindVariable@<eax>(int name@<ecx>, int a2@<eax>, scriptInstance_t inst)
+	unsigned int FindVariable(unsigned int unsignedValue, unsigned int parentId, scriptInstance_t inst, void* call_addr)
+	{
+		int answer;
+		
+		__asm
+		{
+			push inst;
+			mov ecx, unsignedValue;
+			mov eax, parentId;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall GetArrayVariableIndex@<eax>(unsigned int unsignedValue@<eax>, scriptInstance_t inst, unsigned int parentId)
+	unsigned int GetArrayVariableIndex(unsigned int unsignedValue, scriptInstance_t inst, unsigned int parentId, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			push parentId;
+			push inst;
+			mov eax, unsignedValue;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall Scr_GetVariableFieldIndex@<eax>(scriptInstance_t a1@<eax>, unsigned int name@<esi>, unsigned int parentId)
+	unsigned int Scr_GetVariableFieldIndex(scriptInstance_t a1, unsigned int name, unsigned int parentId, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			push parentId;
+			mov eax, a1;
+			mov esi, name;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+		
+		return answer;
+	}
+
+	// VariableValue __usercall Scr_FindVariableField@<edx:eax>(scriptInstance_t inst@<edi>, unsigned int parentId, unsigned int name)
+	//Custom made do not replace!
+	VariableValue Scr_FindVariableField(scriptInstance_t inst, unsigned int parentId, unsigned int name, void* call_addr)
+	{
+		VariableValue answer;
+		VariableUnion u;
+		VariableType typ;
+
+		__asm
+		{
+			push name;
+			push parentId;
+			mov edi, inst;
+			call call_addr;
+
+			mov u, eax;
+			mov typ, edx;
+
+			add esp, 0x8;
+		}
+
+		answer.u = u;
+		answer.type = typ;
+		return answer;
+	}
+
+	// void __usercall ClearVariableField(scriptInstance_t inst@<ecx>, unsigned int id@<eax>, unsigned int name, VariableValue *value)
+	void ClearVariableField(scriptInstance_t inst, unsigned int id, unsigned int name, VariableValue * value, void* call_addr)
+	{
+		__asm
+		{
+			push value;
+			push name;
+			mov ecx, inst;
+			mov eax, id;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// unsigned int __usercall GetVariable@<eax>(scriptInstance_t a1@<eax>, unsigned int parentId, unsigned int name)
+	unsigned int GetVariable(scriptInstance_t a1, unsigned int parentId, unsigned int name, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			push name;
+			push parentId;
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall GetNewVariable@<eax>(scriptInstance_t a1@<eax>, unsigned int a2@<ecx>, unsigned int a3@<edi>)
+	unsigned int GetNewVariable(scriptInstance_t a1, unsigned int a2, unsigned int a3, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			mov ecx, a2;
+			mov edi, a3;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall GetObjectVariable@<eax>(unsigned int a1@<eax>, scriptInstance_t inst, unsigned int parentId)
+	unsigned int GetObjectVariable(unsigned int a1, scriptInstance_t inst, unsigned int parentId, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			push parentId;
+			push inst;
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall GetNewObjectVariable@<eax>(scriptInstance_t inst@<eax>, unsigned int name@<ecx>, unsigned int parentId@<edi>)
+	unsigned int GetNewObjectVariable(scriptInstance_t inst, unsigned int name, unsigned int parentId, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, inst;
+			mov ecx, name;
+			mov edi, parentId;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall RemoveVariable(unsigned int name@<ecx>, unsigned int parentId@<edi>, scriptInstance_t inst@<esi>)
+	void RemoveVariable(unsigned int name, unsigned int parentId, scriptInstance_t inst, void* call_addr)
+	{
+		__asm
+		{
+			mov ecx, name;
+			mov edi, parentId;
+			mov esi, inst;
+			call call_addr;
+		}
+	}
+
+	// void __usercall RemoveNextVariable(scriptInstance_t a1@<edi>, unsigned int parentId)
+	void RemoveNextVariable(scriptInstance_t a1, unsigned int parentId, void* call_addr)
+	{
+		__asm
+		{
+			push parentId;
+			mov edi, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall SafeRemoveVariable(unsigned int unsignedValue@<ecx>, unsigned int parentId@<edi>, scriptInstance_t inst@<esi>)
+	void SafeRemoveVariable(unsigned int unsignedValue, unsigned int parentId, scriptInstance_t inst, void* call_addr)
+	{
+		__asm
+		{
+			mov ecx, unsignedValue;
+			mov edi, parentId;
+			mov esi, inst;
+			call call_addr;
+		}
+	}
+
+	// void __usercall SetVariableValue(scriptInstance_t a1@<eax>, VariableValue *a2@<edi>, unsigned int a3)
+	void SetVariableValue(scriptInstance_t a1, VariableValue * a2, unsigned int a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, a1;
+			mov edi, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// VariableValue __usercall Scr_EvalVariable@<edx:eax>(scriptInstance_t a1@<eax>, unsigned int a2)
+	//Custom made Do not touch!
+	VariableValue Scr_EvalVariable(scriptInstance_t a1, unsigned int a2, void* call_addr)
+	{
+		VariableValue answer;
+		VariableUnion u;
+		VariableType typ;
+
+		__asm
+		{
+			push a2;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x4;
+
+			mov u, eax;
+			mov typ, edx;
+		}
+
+		answer.u = u;
+		answer.type = typ;
+		return answer;
+	}
+
+	// unsigned int __usercall Scr_EvalVariableObject@<eax>(scriptInstance_t inst@<ecx>, int a2@<eax>)
+	unsigned int Scr_EvalVariableObject(scriptInstance_t inst, int a2, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov ecx, inst;
+			mov eax, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// VariableValue __usercall Scr_EvalVariableEntityField@<edx:eax>(unsigned int entId@<ecx>, scriptInstance_t inst, unsigned int name)
+	//Custom made Do not touch
+	VariableValue Scr_EvalVariableEntityField(unsigned int entId, scriptInstance_t inst, unsigned int name, void* call_addr)
+	{
+		VariableValue answer;
+		VariableUnion u;
+		VariableType typ;
+
+		__asm
+		{
+			push name;
+			push inst;
+			mov ecx, entId;
+			call call_addr;
+			mov u, eax;
+			mov typ, edx;
+			add esp, 0x8;
+		}
+		
+		answer.u = u;
+		answer.type = typ;
+		return answer;
+	}
+
+	// VariableValue __usercall Scr_EvalVariableField@<edx:eax>(scriptInstance_t inst@<eax>, unsigned int id@<edx>)
+	//Custom made do not touch
+	VariableValue Scr_EvalVariableField(scriptInstance_t inst, unsigned int id, void* call_addr)
+	{
+		VariableValue answer;
+		VariableUnion u;
+		VariableType typ;
+
+		__asm
+		{
+			mov eax, inst;
+			mov edx, id;
+			call call_addr;
+			mov u, eax;
+			mov typ, edx;
+		}
+
+		answer.u = u;
+		answer.type = typ;
+		return answer;
+	}
+
+	// void __usercall Scr_EvalSizeValue(scriptInstance_t a1@<eax>, VariableValue *value)
+	void Scr_EvalSizeValue(scriptInstance_t a1, VariableValue * value, void* call_addr)
+	{
+		__asm
+		{
+			push value;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// VariableValueInternal_u __usercall GetObject@<eax>(scriptInstance_t a1@<eax>, unsigned int a2@<ecx>)
+	unsigned int GetObject(scriptInstance_t a1, unsigned int a2, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall GetArray@<eax>(scriptInstance_t inst@<eax>, unsigned int a2@<ecx>)
+	unsigned int GetArray(scriptInstance_t inst, unsigned int a2, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, inst;
+			mov ecx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall Scr_EvalBoolComplement(scriptInstance_t a1@<eax>, VariableValue *a2@<esi>)
+	void Scr_EvalBoolComplement(scriptInstance_t a1, VariableValue * a2, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			mov esi, a2;
+			call call_addr;
+		}
+	}
+
+	// void __usercall Scr_CastBool(scriptInstance_t a1@<eax>, VariableValue *a2@<esi>)
+	void Scr_CastBool(scriptInstance_t a1, VariableValue * a2, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			mov esi, a2;
+			call call_addr;
+		}
+	}
+
+	// char __usercall Scr_CastString@<al>(scriptInstance_t a1@<edi>, VariableValue *a2@<esi>)
+	char Scr_CastString(scriptInstance_t a1, VariableValue * a2, void* call_addr)
+	{
+		char answer;
+		
+		__asm
+		{
+			mov edi, a1;
+			mov esi, a2;
+			call call_addr;
+			mov answer, al;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall Scr_CastDebugString(scriptInstance_t a1@<ecx>, VariableValue *a2@<eax>)
+	void Scr_CastDebugString(scriptInstance_t a1, VariableValue * a2, void* call_addr)
+	{
+		__asm
+		{
+			mov ecx, a1;
+			mov eax, a2;
+			call call_addr;
+		}
+	}
+
+	// void __usercall Scr_CastVector(scriptInstance_t a1@<eax>, VariableValue *a2@<esi>)
+	void Scr_CastVector(scriptInstance_t a1, VariableValue * a2, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			mov esi, a2;
+			call call_addr;
+		}
+	}
+
+	// VariableUnion __usercall Scr_EvalFieldObject@<eax>(VariableValue *a1@<eax>, scriptInstance_t inst, int a3)
+	VariableUnion Scr_EvalFieldObject(VariableValue * a1, scriptInstance_t inst, int a3, void* call_addr)
+	{
+		VariableUnion answer;
+		
+		__asm
+		{
+			push a3;
+			push inst;
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall Scr_UnmatchingTypesError(scriptInstance_t a1@<eax>, VariableValue *a2@<esi>, VariableValue *value)
+	void Scr_UnmatchingTypesError(scriptInstance_t a1, VariableValue * a2, VariableValue * value, void* call_addr)
+	{
+		__asm
+		{
+			push value;
+			mov eax, a1;
+			mov esi, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_CastWeakerPair(VariableValue *a1@<ecx>, VariableValue *a2@<edi>, scriptInstance_t a3@<eax>)
+	void Scr_CastWeakerPair(VariableValue * a1, VariableValue * a2, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			mov ecx, a1;
+			mov edi, a2;
+			mov eax, a3;
+			call call_addr;
+		}
+	}
+
+	// void __usercall Scr_CastWeakerStringPair(VariableValue *a1@<eax>, VariableValue *a2@<ecx>, scriptInstance_t inst)
+	void Scr_CastWeakerStringPair(VariableValue * a1, VariableValue * a2, scriptInstance_t inst, void* call_addr)
+	{
+		__asm
+		{
+			push inst;
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalOr(VariableValue *result@<eax>, VariableValue *a2@<ecx>, scriptInstance_t a3)
+	void Scr_EvalOr(VariableValue * result, VariableValue * a2, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, result;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalExOr(VariableValue *result@<eax>, VariableValue *a2@<ecx>, scriptInstance_t a3)
+	void Scr_EvalExOr(VariableValue * result, VariableValue * a2, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, result;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalAnd(VariableValue *result@<eax>, VariableValue *a2@<ecx>, scriptInstance_t a3)
+	void Scr_EvalAnd(VariableValue * result, VariableValue * a2, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, result;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalEquality(VariableValue *a1@<eax>, scriptInstance_t inst, VariableValue *a4)
+	void Scr_EvalEquality(VariableValue * a1, scriptInstance_t inst, VariableValue * a4, void* call_addr)
+	{
+		__asm
+		{
+			push a4;
+			push inst;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// void __usercall Scr_EvalLess(VariableValue *a1@<eax>, VariableValue *a2@<ecx>, scriptInstance_t a3)
+	void Scr_EvalLess(VariableValue * a1, VariableValue * a2, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalGreaterEqual(scriptInstance_t a1@<eax>, VariableValue *a2@<esi>, VariableValue *a3)
+	void Scr_EvalGreaterEqual(scriptInstance_t a1, VariableValue * a2, VariableValue * a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, a1;
+			mov esi, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalGreater(VariableValue *a1@<eax>, VariableValue *a2@<ecx>, scriptInstance_t a3)
+	void Scr_EvalGreater(VariableValue * a1, VariableValue * a2, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalLessEqual(scriptInstance_t a1@<eax>, VariableValue *a2@<esi>, VariableValue *a3)
+	void Scr_EvalLessEqual(scriptInstance_t a1, VariableValue * a2, VariableValue * a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, a1;
+			mov esi, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalShiftLeft(VariableValue *result@<eax>, VariableValue *a2@<ecx>, scriptInstance_t a3)
+	void Scr_EvalShiftLeft(VariableValue * result, VariableValue * a2, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, result;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalShiftRight(VariableValue *result@<eax>, VariableValue *a2@<ecx>, scriptInstance_t a3)
+	void Scr_EvalShiftRight(VariableValue * result, VariableValue * a2, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, result;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalPlus(scriptInstance_t a@<ecx>, VariableValue *a1, VariableValue *a2)
+	void Scr_EvalPlus(scriptInstance_t a, VariableValue * a1, VariableValue * a2, void* call_addr)
+	{
+		__asm
+		{
+			push a2;
+			push a1;
+			mov ecx, a;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// void __usercall Scr_EvalMinus(VariableValue *a1@<eax>, scriptInstance_t a2, VariableValue *a3)
+	void Scr_EvalMinus(VariableValue * a1, scriptInstance_t a2, VariableValue * a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			push a2;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// void __usercall Scr_EvalMultiply(VariableValue *a1@<eax>, scriptInstance_t a2, VariableValue *a3)
+	void Scr_EvalMultiply(VariableValue * a1, scriptInstance_t a2, VariableValue * a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			push a2;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// void __usercall Scr_EvalDivide(VariableValue *a1@<eax>, scriptInstance_t inst, VariableValue *a3)
+	void Scr_EvalDivide(VariableValue * a1, scriptInstance_t inst, VariableValue * a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			push inst;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// void __usercall Scr_EvalMod(scriptInstance_t a1@<eax>, VariableValue *a2@<ecx>, VariableValue *a3)
+	void Scr_EvalMod(scriptInstance_t a1, VariableValue * a2, VariableValue * a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_EvalBinaryOperator(scriptInstance_t a1@<eax>, VariableValue *a2@<ecx>, OpcodeVM a4, VariableValue *a5)
+	void Scr_EvalBinaryOperator(scriptInstance_t a1, VariableValue * a2, OpcodeVM a4, VariableValue * a5, void* call_addr)
+	{
+		__asm
+		{
+			push a5;
+			push a4;
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// void __usercall Scr_FreeEntityNum(scriptInstance_t inst@<ecx>, unsigned int result@<eax>, unsigned int a3)
+	void Scr_FreeEntityNum(scriptInstance_t inst, unsigned int classnum, unsigned int entnum, void* call_addr)
+	{
+		__asm
+		{
+			push entnum;
+			mov ecx, inst;
+			mov eax, classnum;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_SetClassMap(scriptInstance_t a1@<esi>, unsigned int a2)
+	void Scr_SetClassMap(scriptInstance_t a1, unsigned int a2, void* call_addr)
+	{
+		__asm
+		{
+			push a2;
+			mov esi, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// void __usercall Scr_RemoveClassMap(unsigned int result@<eax>, scriptInstance_t a2@<edi>)
+	void Scr_RemoveClassMap(unsigned int result, scriptInstance_t a2, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, result;
+			mov edi, a2;
+			call call_addr;
+		}
+	}
+
+	// void __usercall Scr_AddClassField(scriptInstance_t inst@<ecx>, unsigned int a2@<eax>, char *name, unsigned int a4)
+	void Scr_AddClassField(scriptInstance_t inst, unsigned int classnum, const char * name, unsigned int offset_, void* call_addr)
+	{
+		__asm
+		{
+			push offset_;
+			push name;
+			mov ecx, inst;
+			mov eax, classnum;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	// int __usercall Scr_GetOffset@<eax>(char *name@<eax>, scriptInstance_t inst@<edi>, classNum_e classNum)
+	VariableUnion Scr_GetOffset(const char * name, scriptInstance_t inst, classNum_e classNum, void* call_addr)
+	{
+		VariableUnion answer;
+		
+		__asm
+		{
+			push classNum;
+			mov eax, name;
+			mov edi, inst;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall FindEntityId@<eax>(unsigned int entClass@<eax>, int entNum@<ecx>, scriptInstance_t inst@<edi>)
+	unsigned int FindEntityId(unsigned int entClass, int entNum, scriptInstance_t inst, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, entClass;
+			mov ecx, entNum;
+			mov edi, inst;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall Scr_GetEntityId@<eax>(int entNum@<eax>, scriptInstance_t inst, classNum_e classnum, int clientnum)
+	unsigned int Scr_GetEntityId(int entNum, scriptInstance_t inst, classNum_e classnum, int clientnum, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			push clientnum;
+			push classnum;
+			push inst;
+			mov eax, entNum;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0xC;
+		}
+		
+		return answer;
+	}
+
+	// unsigned int __usercall Scr_FindArrayIndex@<eax>(scriptInstance_t a1@<eax>, VariableValue *a2@<ecx>, int a3)
+	unsigned int Scr_FindArrayIndex(scriptInstance_t a1, VariableValue * a2, unsigned int a3, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			push a3;
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall Scr_EvalArray(scriptInstance_t a2@<ecx>, VariableValue *eax0@<eax>, VariableValue *a3)
+	void Scr_EvalArray(scriptInstance_t a2, VariableValue * eax0, VariableValue * a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov ecx, a2;
+			mov eax, eax0;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// unsigned int __usercall Scr_EvalArrayRef@<eax>(scriptInstance_t a2@<ecx>, unsigned int eax0@<eax>)
+	unsigned int Scr_EvalArrayRef(scriptInstance_t a2, unsigned int eax0, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov ecx, a2;
+			mov eax, eax0;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall ClearArray(unsigned int parentId@<eax>, scriptInstance_t inst@<ecx>, VariableValue *value)
+	void ClearArray(unsigned int parentId, scriptInstance_t inst, VariableValue * value, void* call_addr)
+	{
+		__asm
+		{
+			push value;
+			mov eax, parentId;
+			mov ecx, inst;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// unsigned int __usercall SetEmptyArray@<eax>(scriptInstance_t a1@<edi>, unsigned int a2)
+	void SetEmptyArray(scriptInstance_t a1, unsigned int a2, void* call_addr)
+	{
+		__asm
+		{
+			push a2;
+			mov edi, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// scr_entref_t *__usercall Scr_GetEntityIdRef@<eax>(scr_entref_t *result@<eax>, scriptInstance_t a2@<ecx>, unsigned int a3)
+	scr_entref_t * Scr_GetEntityIdRef(scr_entref_t * result, scriptInstance_t a2, unsigned int a3, void* call_addr)
+	{
+		scr_entref_t * answer;
+		
+		__asm
+		{
+			push a3;
+			mov eax, result;
+			mov ecx, a2;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall Scr_CopyEntityNum(unsigned int a1@<eax>, unsigned int parentId)
+	void CopyEntity(unsigned int parentId, unsigned int newParentId, void* call_addr)
+	{
+		__asm
+		{
+			push newParentId;
+			mov eax, parentId;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// float __usercall Scr_GetEndonUsage@<st0>(unsigned int a1@<ecx>, scriptInstance_t a2@<edi>)
+	float Scr_GetEndonUsage(unsigned int a1, scriptInstance_t a2, void* call_addr)
+	{
+		float answer;
+
+		__asm
+		{
+			mov ecx, a1;
+			mov edi, a2;
+			call call_addr;
+			fstp answer;
+		}
+
+		return answer;
+	}
+
+	// float __usercall Scr_GetThreadUsage@<xmm0>(VariableStackBuffer *a1@<eax>, scriptInstance_t a2@<ecx>, float *a3)
+	float Scr_GetThreadUsage(VariableStackBuffer * a1, scriptInstance_t a2, float * a3, void* call_addr)
+	{
+		float answer;
+		
+		__asm
+		{
+			push a3;
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			movss answer, xmm0;
+			add esp, 0x4;
+		}
+		
+		return answer;
+	}
+
+	// int __usercall Scr_FindField@<eax>(scriptInstance_t a1@<eax>, unsigned __int8 *a2, int *a3)
+	unsigned int Scr_FindField(scriptInstance_t inst, const char * name, int * type_, void* call_addr)
+	{
+		int answer;
+		
+		__asm
+		{
+			push type_;
+			push name;
+			mov eax, inst;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+		
+		return answer;
+	}
+
+	// void __usercall Scr_FreeGameVariable(scriptInstance_t a1@<eax>, int bComplete)
+	void Scr_FreeGameVariable(scriptInstance_t a1, int bComplete, void* call_addr)
+	{
+		__asm
+		{
+			push bComplete;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	// char __usercall Scr_CreateLowercaseString@<al>(int a1@<eax>, const char *a2@<edx>)
+	bool Scr_SLHasLowercaseString(unsigned int a1, const char * a2, void* call_addr)
+	{
+		char answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			mov edx, a2;
+			call call_addr;
+			mov answer, al;
+		}
+		
+		return answer;
+	}
+
+	unsigned int FindObject(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_variable::FindObject(inst, id);
+		return 0;
+	}
+
+	float Scr_GetEntryUsageInternal(scriptInstance_t inst, unsigned int type, VariableUnion u)
+	{
+		//return cscr_variable::Scr_GetEntryUsageInternal(inst, type, u);
+		return 0;
+	}
+
+	float Scr_GetEntryUsage(scriptInstance_t inst, VariableValueInternal* entryValue)
+	{
+		//return cscr_variable::Scr_GetEntryUsage(inst, entryValue);
+		return 0;
+	}
+
+	unsigned int FindFirstSibling(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_variable::FindFirstSibling(inst, id);
+		return 0;
+	}
+
+	unsigned int FindNextSibling(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_variable::FindNextSibling(inst, id);
+		return 0;
+	}
+
+	VariableValue Scr_GetArrayIndexValue(scriptInstance_t inst, unsigned int name)
+	{
+		//return cscr_variable::Scr_GetArrayIndexValue(inst, name);
+		VariableValue l;
+		l.type = VAR_UNDEFINED;
+		return l;
+	}
+
+	void AddRefToObject(scriptInstance_t inst, unsigned int id)
+	{
+		//cscr_variable::AddRefToObject(inst, id);
+	}
+
+	void RemoveRefToEmptyObject(scriptInstance_t inst, unsigned int id)
+	{
+		//cscr_variable::RemoveRefToEmptyObject(inst, id);
+	}
+
+	void Scr_ClearThread(scriptInstance_t inst, unsigned int parentId)
+	{
+		//cscr_variable::Scr_ClearThread(inst, parentId);
+	}
+
+	unsigned int FindObjectVariable(scriptInstance_t inst, unsigned int parentId, unsigned int id)
+	{
+		//return cscr_variable::FindObjectVariable(inst, parentId, id);
+		return 0;
+	}
+
+	void RemoveObjectVariable(scriptInstance_t inst, unsigned int parentId, unsigned int id)
+	{
+		//cscr_variable::RemoveObjectVariable(inst, parentId, id);
+	}
+
+	VariableValueInternal_u* GetVariableValueAddress(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_variable::GetVariableValueAddress(inst, id);
+		return nullptr;
+	}
+
+	void Scr_KillEndonThread(scriptInstance_t inst, unsigned int threadId)
+	{
+		//cscr_variable::Scr_KillEndonThread(inst, threadId);
+	}
+
+	BOOL IsValidArrayIndex(scriptInstance_t inst, unsigned int unsignedValue)
+	{
+		//return cscr_variable::IsValidArrayIndex(inst, unsignedValue);
+		return 0;
+	}
+
+	void RemoveArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
+	{
+		//cscr_variable::RemoveArrayVariable(inst, parentId, unsignedValue);
+	}
+
+	void SafeRemoveArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
+	{
+		//cscr_variable::SafeRemoveArrayVariable(inst, parentId, unsignedValue);
+	}
+
+	void AddRefToVector(scriptInstance_t inst, const float* floatVal)
+	{
+		//cscr_variable::AddRefToVector(inst, floatVal);
+	}
+
+	unsigned int FindArrayVariableIndex(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
+	{
+		//return cscr_variable::FindArrayVariableIndex(inst, parentId, unsignedValue);
+		return 0;
+	}
+
+	unsigned int GetVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name)
+	{
+		//return cscr_variable::GetVariableIndexInternal(inst, parentId, name);
+		return 0;
+	}
+
+	unsigned int GetNewVariableIndexInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name)
+	{
+		//return cscr_variable::GetNewVariableIndexInternal(inst, parentId, name);
+		return 0;
+	}
+
+	unsigned int AllocObject(scriptInstance_t inst)
+	{
+		//return cscr_variable::AllocObject(inst);
+		return 0;
+	}
+
+	VariableType GetValueType(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_variable::GetValueType(inst, id);
+		return (VariableType)0;
+	}
+
+	VariableType GetObjectType(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_variable::GetObjectType(inst, id);
+		return (VariableType)0;
+	}
+
+	float* Scr_AllocVector_(scriptInstance_t inst, const float* v)
+	{
+		//return cscr_variable::Scr_AllocVector_(inst, v);
+		return 0;
+	}
+
+	void Scr_EvalInequality(scriptInstance_t inst, VariableValue* value1, VariableValue* value2)
+	{
+		//cscr_variable::Scr_EvalInequality(inst, value1, value2);
+	}
+
+	unsigned int Scr_EvalArrayRefInternal(scriptInstance_t inst, VariableValue* varValue, VariableValueInternal* parentValue)
+	{
+		//return cscr_variable::Scr_EvalArrayRefInternal(inst, varValue, parentValue);
+		return 0;
+	}
+
+	unsigned int GetNewArrayVariableIndex(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
+	{
+		//return cscr_variable::GetNewArrayVariableIndex(inst, parentId, unsignedValue);
+		return 0;
+	}
+
+	unsigned int GetNewArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
+	{
+		//return cscr_variable::GetNewArrayVariable(inst, parentId, unsignedValue);
+		return 0;
+	}
+
+	unsigned int GetArrayVariable(scriptInstance_t inst, unsigned int parentId, unsigned int unsignedValue)
+	{
+		//return cscr_variable::GetArrayVariable(inst, parentId, unsignedValue);
+		return 0;
+	}
+
+	unsigned int AllocThread(scriptInstance_t inst, unsigned int self)
+	{
+		//return cscr_variable::AllocThread(inst, self);
+		return 0;
+	}
+}
diff --git a/src/game/clientscript/cscr_vm.hpp b/src/game/clientscript/cscr_vm.hpp
new file mode 100644
index 0000000..cec0938
--- /dev/null
+++ b/src/game/clientscript/cscr_vm.hpp
@@ -0,0 +1,182 @@
+#pragma once
+
+namespace game
+{
+	WEAK symbol<void(scriptInstance_t inst)>Scr_VM_Init{ 0x0, 0x693B20 };
+	WEAK symbol<void(scriptInstance_t inst, unsigned int startLocalId, VariableStackBuffer* stackValue)>VM_UnarchiveStack{ 0x0, 0x697BB0 };
+	WEAK symbol<unsigned int(scriptInstance_t inst)>VM_ExecuteInternal{ 0x0, 0x693E80 };
+	WEAK symbol<unsigned int(scriptInstance_t inst, unsigned int localId, const char* pos, unsigned int paramcount)>VM_Execute{ 0x0, 0x6992E0 };
+	WEAK symbol<void(scriptInstance_t inst, int bComplete)>Scr_ShutdownSystem{ 0x0, 0x699930 };
+	WEAK symbol<BOOL()>Scr_IsSystemActive{ 0x0, 0x699C30 };
+	WEAK symbol<scr_animtree_t()>Scr_GetAnimTree{ 0x0, 0x699DD0 };
+	WEAK symbol<unsigned int()>Scr_GetFunc{ 0x0, 0x69A2C0 };
+	WEAK symbol<void(VariableUnion value)>Scr_AddAnim{ 0x0, 0x69A6D0 };
+	WEAK symbol<void(scriptInstance_t inst)>Scr_AddArray{ 0x0, 0x69AA50 };
+
+	inline void* Scr_Init_ADDR() { return CALL_ADDR(0x0, 0x693C20); }
+	void Scr_Init(scriptInstance_t inst, void* call_addr = Scr_Init_ADDR());
+	inline void* Scr_Shutdown_ADDR() { return CALL_ADDR(0x0, 0x693C90); }
+	void Scr_Shutdown(scriptInstance_t inst, void* call_addr = Scr_Shutdown_ADDR());
+	inline void* Scr_ErrorInternal_ADDR() { return CALL_ADDR(0x0, 0x693CF0); }
+	void Scr_ErrorInternal(scriptInstance_t inst, void* call_addr = Scr_ErrorInternal_ADDR());
+	inline void* Scr_ClearOutParams_ADDR() { return CALL_ADDR(0x0, 0x693DA0); }
+	void Scr_ClearOutParams(scriptInstance_t inst, void* call_addr = Scr_ClearOutParams_ADDR());
+	inline void* GetDummyObject_ADDR() { return CALL_ADDR(0x0, 0x693DE0); }
+	unsigned int GetDummyObject(scriptInstance_t inst, void* call_addr = GetDummyObject_ADDR());
+	inline void* GetDummyFieldValue_ADDR() { return CALL_ADDR(0x0, 0x693E30); }
+	unsigned int GetDummyFieldValue(scriptInstance_t inst, void* call_addr = GetDummyFieldValue_ADDR());
+	inline void* VM_CancelNotifyInternal_ADDR() { return CALL_ADDR(0x0, 0x6978C0); }
+	void VM_CancelNotifyInternal(scriptInstance_t inst, unsigned int notifyListOwnerId, unsigned int startLocalId, unsigned int notifyListId, unsigned int notifyNameListId, unsigned int stringValue, void* call_addr = VM_CancelNotifyInternal_ADDR());
+	inline void* VM_CancelNotify_ADDR() { return CALL_ADDR(0x0, 0x697950); }
+	void VM_CancelNotify(scriptInstance_t inst, unsigned int a2, unsigned int a3, void* call_addr = VM_CancelNotify_ADDR());
+	inline void* VM_ArchiveStack_ADDR() { return CALL_ADDR(0x0, 0x697A00); }
+	VariableStackBuffer * VM_ArchiveStack(scriptInstance_t inst, void* call_addr = VM_ArchiveStack_ADDR());
+	inline void* Scr_AddLocalVars_ADDR() { return CALL_ADDR(0x0, 0x697B60); }
+	int Scr_AddLocalVars(scriptInstance_t inst, unsigned int a2, void* call_addr = Scr_AddLocalVars_ADDR());
+	inline void* VM_TerminateStack_ADDR() { return CALL_ADDR(0x0, 0x697D80); }
+	void VM_TerminateStack(scriptInstance_t inst, unsigned int endLocalId, unsigned int startLocalId, VariableStackBuffer* name, void* call_addr = VM_TerminateStack_ADDR());
+	inline void* VM_TrimStack_ADDR() { return CALL_ADDR(0x0, 0x697F20); }
+	void VM_TrimStack(scriptInstance_t inst, unsigned int parentId, VariableStackBuffer * a3, int fromEndon, void* call_addr = VM_TrimStack_ADDR());
+	inline void* Scr_TerminateRunningThread_ADDR() { return CALL_ADDR(0x0, 0x698150); }
+	void Scr_TerminateRunningThread(scriptInstance_t inst, unsigned int a2, void* call_addr = Scr_TerminateRunningThread_ADDR());
+	inline void* Scr_TerminateWaitThread_ADDR() { return CALL_ADDR(0x0, 0x698200); }
+	void Scr_TerminateWaitThread(scriptInstance_t inst, unsigned int a2, unsigned int a3, void* call_addr = Scr_TerminateWaitThread_ADDR());
+	inline void* Scr_CancelWaittill_ADDR() { return CALL_ADDR(0x0, 0x698310); }
+	void Scr_CancelWaittill(scriptInstance_t inst, unsigned int startLocalId, void* call_addr = Scr_CancelWaittill_ADDR());
+	inline void* Scr_TerminateWaittillThread_ADDR() { return CALL_ADDR(0x0, 0x698400); }
+	void Scr_TerminateWaittillThread(scriptInstance_t inst, unsigned int a2, unsigned int a3, void* call_addr = Scr_TerminateWaittillThread_ADDR());
+	inline void* Scr_TerminateThread_ADDR() { return CALL_ADDR(0x0, 0x698610); }
+	void Scr_TerminateThread(unsigned int a2, scriptInstance_t inst, void* call_addr = Scr_TerminateThread_ADDR());
+	inline void* VM_Notify_ADDR() { return CALL_ADDR(0x0, 0x698670); }
+	void VM_Notify(scriptInstance_t inst, int notifyListOwnerId, unsigned int stringValue, VariableValue * top, void* call_addr = VM_Notify_ADDR());
+	inline void* Scr_NotifyNum_Internal_ADDR() { return CALL_ADDR(0x0, 0x698CC0); }
+	void Scr_NotifyNum_Internal(scriptInstance_t inst, int entNum, int entClass, unsigned int notifStr, int numParams, void* call_addr = Scr_NotifyNum_Internal_ADDR());
+	inline void* Scr_CancelNotifyList_ADDR() { return CALL_ADDR(0x0, 0x698DE0); }
+	void Scr_CancelNotifyList(unsigned int notifyListOwnerId, scriptInstance_t inst, void* call_addr = Scr_CancelNotifyList_ADDR());
+	inline void* VM_TerminateTime_ADDR() { return CALL_ADDR(0x0, 0x698FE0); }
+	void VM_TerminateTime(scriptInstance_t inst, unsigned int parentId, void* call_addr = VM_TerminateTime_ADDR());
+	inline void* VM_Resume_ADDR() { return CALL_ADDR(0x0, 0x6990E0); }
+	void VM_Resume(scriptInstance_t inst, unsigned int timeId, void* call_addr = VM_Resume_ADDR());
+	inline void* Scr_ExecThread_ADDR() { return CALL_ADDR(0x0, 0x699560); }
+	unsigned short Scr_ExecThread(scriptInstance_t inst, unsigned int handle, unsigned int paramCount, void* call_addr = Scr_ExecThread_ADDR());
+	inline void* Scr_ExecEntThread_ADDR() { return CALL_ADDR(0x0, 0x699640); }
+	unsigned short Scr_ExecEntThreadNum(scriptInstance_t inst, int entNum, unsigned int handle, int numParams, unsigned int clientNum, void* call_addr = Scr_ExecEntThread_ADDR());
+	inline void* Scr_AddExecThread_ADDR() { return CALL_ADDR(0x0, 0x699730); }
+	void Scr_AddExecThread(scriptInstance_t inst, unsigned int handle, void* call_addr = Scr_AddExecThread_ADDR());
+	inline void* VM_SetTime_ADDR() { return CALL_ADDR(0x0, 0x6997E0); }
+	void VM_SetTime(scriptInstance_t inst, void* call_addr = VM_SetTime_ADDR());
+	inline void* Scr_InitSystem_ADDR() { return CALL_ADDR(0x0, 0x699860); }
+	void Scr_InitSystem(scriptInstance_t inst, void* call_addr = Scr_InitSystem_ADDR());
+	inline void* Scr_GetInt_ADDR() { return CALL_ADDR(0x0, 0x699C50); }
+	int Scr_GetInt(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetInt_ADDR());
+	inline void* Scr_GetAnim_ADDR() { return CALL_ADDR(0x0, 0x699CE0); }
+	scr_anim_s Scr_GetAnim(unsigned int index, XAnimTree_s * anims, void* call_addr = Scr_GetAnim_ADDR());
+	inline void* Scr_GetFloat_ADDR() { return CALL_ADDR(0x0, 0x699E90); }
+	float Scr_GetFloat(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetFloat_ADDR());
+	inline void* Scr_GetConstString_ADDR() { return CALL_ADDR(0x0, 0x699F30); }
+	unsigned int Scr_GetConstString(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetConstString_ADDR());
+	inline void* Scr_GetConstLowercaseString_ADDR() { return CALL_ADDR(0x0, 0x699FB0); }
+	unsigned int Scr_GetConstLowercaseString(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetConstLowercaseString_ADDR());
+	inline void* Scr_GetString_ADDR() { return CALL_ADDR(0x0, 0x69A0D0); }
+	const char * Scr_GetString(unsigned int index, scriptInstance_t inst, void* call_addr = Scr_GetString_ADDR());
+	inline void* Scr_GetConstStringIncludeNull_ADDR() { return CALL_ADDR(0x0, 0x69A100); }
+	unsigned int Scr_GetConstStringIncludeNull(scriptInstance_t inst, void* call_addr = Scr_GetConstStringIncludeNull_ADDR());
+	inline void* Scr_GetDebugString_ADDR() { return CALL_ADDR(0x0, 0x69A130); }
+	char * Scr_GetDebugString(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetDebugString_ADDR());
+	inline void* Scr_GetConstIString_ADDR() { return CALL_ADDR(0x0, 0x69A1A0); }
+	unsigned int Scr_GetConstIString(unsigned int index, void* call_addr = Scr_GetConstIString_ADDR());
+	inline void* Scr_GetVector_ADDR() { return CALL_ADDR(0x0, 0x69A220); }
+	void Scr_GetVector(scriptInstance_t inst, float * value, unsigned int index, void* call_addr = Scr_GetVector_ADDR());
+	inline void* Scr_GetEntityRef_ADDR() { return CALL_ADDR(0x0, 0x69A330); }
+	scr_entref_t * Scr_GetEntityRef(scriptInstance_t inst, scr_entref_t * retstr, unsigned int index, void* call_addr = Scr_GetEntityRef_ADDR());
+	inline void* Scr_GetObject_ADDR() { return CALL_ADDR(0x0, 0x69A460); }
+	VariableUnion Scr_GetObject(scriptInstance_t inst, void* call_addr = Scr_GetObject_ADDR());
+	inline void* Scr_GetType_ADDR() { return CALL_ADDR(0x0, 0x69A4E0); }
+	VariableType Scr_GetType(scriptInstance_t inst, unsigned int index, void* call_addr = Scr_GetType_ADDR());
+	inline void* Scr_GetTypeName_ADDR() { return CALL_ADDR(0x0, 0x69A530); }
+	char * Scr_GetTypeName(scriptInstance_t inst, void* call_addr = Scr_GetTypeName_ADDR());
+	inline void* Scr_GetPointerType_ADDR() { return CALL_ADDR(0x0, 0x69A580); }
+	VariableType Scr_GetPointerType(scriptInstance_t inst, unsigned int a2, void* call_addr = Scr_GetPointerType_ADDR());
+	inline void* Scr_AddInt_ADDR() { return CALL_ADDR(0x0, 0x69A610); }
+	void Scr_AddInt(scriptInstance_t inst, int value, void* call_addr = Scr_AddInt_ADDR());
+	inline void* Scr_AddFloat_ADDR() { return CALL_ADDR(0x0, 0x69A670); }
+	void Scr_AddFloat(scriptInstance_t inst, float value, void* call_addr = Scr_AddFloat_ADDR());
+	inline void* Scr_AddUndefined_ADDR() { return CALL_ADDR(0x0, 0x69A720); }
+	void Scr_AddUndefined(scriptInstance_t inst, void* call_addr = Scr_AddUndefined_ADDR());
+	inline void* Scr_AddObject_ADDR() { return CALL_ADDR(0x0, 0x69A770); }
+	void Scr_AddObject(scriptInstance_t inst, unsigned int entid, void* call_addr = Scr_AddObject_ADDR());
+	inline void* Scr_AddString_ADDR() { return CALL_ADDR(0x0, 0x69A7E0); }
+	void Scr_AddString(scriptInstance_t inst, const char * string, void* call_addr = Scr_AddString_ADDR());
+	inline void* Scr_AddIString_ADDR() { return CALL_ADDR(0x0, 0x69A860); }
+	void Scr_AddIString(char * string, void* call_addr = Scr_AddIString_ADDR());
+	inline void* Scr_AddConstString_ADDR() { return CALL_ADDR(0x0, 0x69A8D0); }
+	void Scr_AddConstString(scriptInstance_t inst, unsigned int id, void* call_addr = Scr_AddConstString_ADDR());
+	inline void* Scr_AddVector_ADDR() { return CALL_ADDR(0x0, 0x69A940); }
+	void Scr_AddVector(scriptInstance_t inst, float * value, void* call_addr = Scr_AddVector_ADDR());
+	inline void* Scr_MakeArray_ADDR() { return CALL_ADDR(0x0, 0x69A9D0); }
+	void Scr_MakeArray(scriptInstance_t inst, void* call_addr = Scr_MakeArray_ADDR());
+	inline void* Scr_AddArrayStringIndexed_ADDR() { return CALL_ADDR(0x0, 0x69AAF0); }
+	void Scr_AddArrayStringIndexed(unsigned int id, scriptInstance_t inst, void* call_addr = Scr_AddArrayStringIndexed_ADDR());
+	inline void* Scr_Error_ADDR() { return CALL_ADDR(0x0, 0x69AB70); }
+	void Scr_Error(const char * err, scriptInstance_t inst, int is_terminal, void* call_addr = Scr_Error_ADDR());
+	inline void* Scr_TerminalError_ADDR() { return CALL_ADDR(0x0, 0x69ABD0); }
+	void Scr_TerminalError(scriptInstance_t inst, const char * Source, void* call_addr = Scr_TerminalError_ADDR());
+	inline void* Scr_ParamError_ADDR() { return CALL_ADDR(0x0, 0x69AC00); }
+	void Scr_ParamError(int a1, scriptInstance_t a2, const char * Source, void* call_addr = Scr_ParamError_ADDR());
+	inline void* Scr_ObjectError_ADDR() { return CALL_ADDR(0x0, 0x69AC30); }
+	void Scr_ObjectError(scriptInstance_t inst, const char * a2, void* call_addr = Scr_ObjectError_ADDR());
+	inline void* SetEntityFieldValue_ADDR() { return CALL_ADDR(0x0, 0x69AC50); }
+	bool SetEntityFieldValue(scriptInstance_t inst, int offset, int entnum, classNum_e classnum, int clientNum, VariableValue * value, void* call_addr = SetEntityFieldValue_ADDR());
+	inline void* GetEntityFieldValue_ADDR() { return CALL_ADDR(0x0, 0x69ACE0); }
+	VariableValue GetEntityFieldValue(int offset, int entnum, scriptInstance_t inst, int classnum, int clientNum, void* call_addr = GetEntityFieldValue_ADDR());
+	inline void* Scr_SetStructField_ADDR() { return CALL_ADDR(0x0, 0x69AD50); }
+	void Scr_SetStructField(unsigned int a1, unsigned int a2, scriptInstance_t inst, void* call_addr = Scr_SetStructField_ADDR());
+	inline void* Scr_IncTime_ADDR() { return CALL_ADDR(0x0, 0x69ADE0); }
+	void Scr_IncTime(scriptInstance_t inst, void* call_addr = Scr_IncTime_ADDR());
+	inline void* Scr_RunCurrentThreads_ADDR() { return CALL_ADDR(0x0, 0x69AE30); }
+	void Scr_RunCurrentThreads(scriptInstance_t inst, void* call_addr = Scr_RunCurrentThreads_ADDR());
+	inline void* Scr_ResetTimeout_ADDR() { return CALL_ADDR(0x0, 0x69AE60); }
+	void Scr_ResetTimeout(scriptInstance_t inst, void* call_addr = Scr_ResetTimeout_ADDR());
+	void SetVariableFieldValue(scriptInstance_t inst, unsigned int id, VariableValue* value);
+
+	void SetNewVariableValue(scriptInstance_t inst, unsigned int id, VariableValue* value);
+
+	void Scr_ClearErrorMessage(scriptInstance_t inst);
+	void VM_Shutdown(scriptInstance_t inst);
+	void Scr_ShutdownVariables(scriptInstance_t inst);
+	void ClearVariableValue(scriptInstance_t inst, unsigned int id);
+	unsigned int Scr_GetThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId);
+	void Scr_RemoveThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId);
+	unsigned int GetArraySize(scriptInstance_t inst, unsigned int id);
+	void IncInParam(scriptInstance_t inst);
+	unsigned int GetParentLocalId(scriptInstance_t inst, unsigned int threadId);
+	void Scr_ClearWaitTime(scriptInstance_t inst, unsigned int startLocalId);
+	void Scr_SetThreadWaitTime(scriptInstance_t inst, unsigned int startLocalId, unsigned int waitTime);
+	void Scr_SetThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId, unsigned int stringValue);
+	void Scr_DebugTerminateThread(scriptInstance_t inst, int topThread);
+	unsigned int Scr_GetThreadWaitTime(scriptInstance_t inst, unsigned int startLocalId);
+	const char* Scr_GetStackThreadPos(scriptInstance_t inst, unsigned int endLocalId, VariableStackBuffer* stackValue, bool killThread);
+	unsigned int Scr_GetSelf(scriptInstance_t inst, unsigned int threadId);
+	unsigned int GetVariableKeyObject(scriptInstance_t inst, unsigned int id);
+	int MT_Realloc(scriptInstance_t inst, int oldNumBytes, int newNumbytes);
+	void CScr_GetObjectField(classNum_e classnum, int entnum, int clientNum, int offset);
+	int CScr_SetObjectField(classNum_e classnum, int entnum, int clientNum, int offset);
+	void Scr_SetErrorMessage(scriptInstance_t inst, const char* error);
+	bool Scr_IsStackClear(scriptInstance_t inst);
+	void SL_CheckExists(scriptInstance_t inst, unsigned int stringValue);
+	const char* Scr_ReadCodePos(scriptInstance_t inst, const char** pos);
+	unsigned int Scr_ReadUnsignedInt(scriptInstance_t inst, const char** pos);
+	unsigned short Scr_ReadUnsignedShort(scriptInstance_t inst, const char** pos);
+	unsigned char Scr_ReadUnsignedByte(scriptInstance_t inst, const char** pos);
+	float Scr_ReadFloat(scriptInstance_t inst, const char** pos);
+	const float* Scr_ReadVector(scriptInstance_t inst, const char** pos);
+	BOOL IsFieldObject(scriptInstance_t inst, unsigned int id);
+	void RemoveVariableValue(scriptInstance_t inst, unsigned int parentId, unsigned int index);
+	VariableStackBuffer* GetRefVariableStackBuffer(scriptInstance_t inst, int id);
+	unsigned int GetNewObjectVariableReverse(scriptInstance_t inst, unsigned int parentId, unsigned int id);
+	unsigned int GetNewVariableIndexReverseInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name);
+	unsigned int Scr_GetLocalVar(scriptInstance_t inst, int pos);
+	void Scr_EvalBoolNot(scriptInstance_t inst, VariableValue* value);
+	unsigned int GetInternalVariableIndex(scriptInstance_t inst, unsigned int unsignedValue);
+	const char* Scr_ReadData(scriptInstance_t inst, const char** pos, unsigned int count);
+}
\ No newline at end of file
diff --git a/src/game/clientscript/cscr_vm_w.cpp b/src/game/clientscript/cscr_vm_w.cpp
new file mode 100644
index 0000000..455d6f6
--- /dev/null
+++ b/src/game/clientscript/cscr_vm_w.cpp
@@ -0,0 +1,1006 @@
+#include <stdinc.hpp>
+
+namespace game
+{
+	//custom made don't replace VariableValue __usercall GetEntityFieldValue@<edx:eax>(int offset@<eax>, int entnum@<ecx>, scriptInstance_t inst, int classnum, int clientNum)
+	VariableValue GetEntityFieldValue/*@<eax>*/(int offset_, int entnum, scriptInstance_t inst, int classnum, int clientNum, void* call_addr)
+	{
+		VariableValue answer;
+		VariableUnion u;
+		VariableType typ;
+
+		__asm
+		{
+			push clientNum;
+			push classnum;
+			push inst;
+			mov ecx, entnum;
+			mov eax, offset_;
+			call call_addr;
+
+			mov u, eax;
+			mov typ, edx;
+
+			add esp, 0xC;
+		}
+		answer.u = u;
+		answer.type = typ;
+		return answer;
+	}
+
+	void Scr_Init(scriptInstance_t a1/*@<eax>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+		}
+	}
+
+	void Scr_Shutdown(scriptInstance_t a1/*@<edi>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov edi, a1;
+			call call_addr;
+		}
+	}
+
+	void Scr_ErrorInternal(scriptInstance_t a1/*@<eax>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+		}
+	}
+
+	void Scr_ClearOutParams(scriptInstance_t a1/*@<edi>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov edi, a1;
+			call call_addr;
+		}
+	}
+
+	unsigned int GetDummyObject/*@<eax>*/(scriptInstance_t a1/*@<edi>*/, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov edi, a1;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	unsigned int GetDummyFieldValue/*@<eax>*/(scriptInstance_t a1/*@<eax>*/, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	void VM_CancelNotifyInternal(scriptInstance_t inst/*@<ecx>*/, unsigned int notifyListOwnerId/*@<eax>*/, unsigned int startLocalId, unsigned int notifyListId, unsigned int notifyNameListId, unsigned int stringValue, void* call_addr)
+	{
+		__asm
+		{
+			push stringValue;
+			push notifyNameListId;
+			push notifyListId;
+			push startLocalId;
+			mov ecx, inst;
+			mov eax, notifyListOwnerId;
+			call call_addr;
+			add esp, 0x10;
+		}
+	}
+
+	void VM_CancelNotify(scriptInstance_t a1/*@<edi>*/, unsigned int a2, unsigned int a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			push a2;
+			mov edi, a1;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	VariableStackBuffer * VM_ArchiveStack/*@<eax>*/(scriptInstance_t inst/*@<eax>*/, void* call_addr)
+	{
+		VariableStackBuffer * answer;
+		
+		__asm
+		{
+			mov eax, inst;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	int Scr_AddLocalVars/*@<eax>*/(scriptInstance_t a1/*@<eax>*/, unsigned int a2/*@<edx>*/, void* call_addr)
+	{
+		int answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			mov edx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	void VM_TerminateStack(scriptInstance_t inst/*@<esi>*/, unsigned int endLocalId, unsigned int startLocalId, VariableStackBuffer * name, void* call_addr)
+	{
+		__asm
+		{
+			push name;
+			push startLocalId;
+			push endLocalId;
+			mov esi, inst;
+			call call_addr;
+			add esp, 0xC;
+		}
+	}
+
+	void VM_TrimStack(scriptInstance_t a1/*@<eax>*/, unsigned int parentId, VariableStackBuffer * a3, int fromEndon, void* call_addr)
+	{
+		__asm
+		{
+			push fromEndon;
+			push a3;
+			push parentId;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0xC;
+		}
+	}
+
+	void Scr_TerminateRunningThread(scriptInstance_t a1/*@<edx>*/, unsigned int a2, void* call_addr)
+	{
+		__asm
+		{
+			push a2;
+			mov edx, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void Scr_TerminateWaitThread(scriptInstance_t a1/*@<eax>*/, unsigned int a2, unsigned int a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			push a2;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	void Scr_CancelWaittill(scriptInstance_t inst/*@<ecx>*/, unsigned int startLocalId/*@<eax>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov ecx, inst;
+			mov eax, startLocalId;
+			call call_addr;
+		}
+	}
+
+	void Scr_TerminateWaittillThread(scriptInstance_t a1/*@<eax>*/, unsigned int a2, unsigned int a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			push a2;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x8;
+		}
+	}
+
+	void Scr_TerminateThread(unsigned int a2/*@<edi>*/, scriptInstance_t a3/*@<esi>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov edi, a2;
+			mov esi, a3;
+			call call_addr;
+		}
+	}
+
+	void VM_Notify(scriptInstance_t inst/*@<eax>*/, int notifyListOwnerId, unsigned int stringValue, VariableValue * top, void* call_addr)
+	{
+		__asm
+		{
+			push top;
+			push stringValue;
+			push notifyListOwnerId;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0xC;
+		}
+	}
+
+	void Scr_NotifyNum_Internal(scriptInstance_t inst/*@<eax>*/, int entNum, int entClass, unsigned int notifStr, int numParams, void* call_addr)
+	{
+		__asm
+		{
+			push numParams;
+			push notifStr;
+			push entClass;
+			push entNum;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0x10;
+		}
+	}
+
+	void Scr_CancelNotifyList(unsigned int notifyListOwnerId/*@<eax>*/, scriptInstance_t inst, void* call_addr)
+	{
+		__asm
+		{
+			push inst;
+			mov eax, notifyListOwnerId;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void VM_TerminateTime(scriptInstance_t a1/*@<eax>*/, unsigned int parentId, void* call_addr)
+	{
+		__asm
+		{
+			push parentId;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void VM_Resume(scriptInstance_t inst/*@<eax>*/, unsigned int timeId, void* call_addr)
+	{
+		__asm
+		{
+			push timeId;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	unsigned short Scr_ExecThread/*@<ax>*/(scriptInstance_t inst/*@<edi>*/, unsigned int handle, unsigned int paramCount, void* call_addr)
+	{
+		unsigned __int16 answer;
+		
+		__asm
+		{
+			push paramCount;
+			push handle;
+			mov edi, inst;
+			call call_addr;
+			mov answer, ax;
+			add esp, 0x8;
+		}
+		
+		return answer;
+	}
+
+	unsigned short Scr_ExecEntThreadNum/*@<ax>*/(scriptInstance_t inst/*@<edi>*/, int entNum, unsigned int handle, int numParams, unsigned int clientNum, void* call_addr)
+	{
+		unsigned __int16 answer;
+		
+		__asm
+		{
+			push clientNum;
+			push numParams;
+			push handle;
+			push entNum;
+			mov edi, inst;
+			call call_addr;
+			mov answer, ax;
+			add esp, 0x10;
+		}
+		
+		return answer;
+	}
+
+	void Scr_AddExecThread(scriptInstance_t a1/*@<edi>*/, unsigned int handle, void* call_addr)
+	{
+		__asm
+		{
+			push handle;
+			mov edi, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void VM_SetTime(scriptInstance_t a1/*@<eax>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+		}
+	}
+
+	void Scr_InitSystem(scriptInstance_t a1/*@<edi>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov edi, a1;
+			call call_addr;
+		}
+	}
+
+	int Scr_GetInt/*@<eax>*/(scriptInstance_t inst/*@<eax>*/, unsigned int index/*@<ecx>*/, void* call_addr)
+	{
+		int answer;
+		
+		__asm
+		{
+			mov eax, inst;
+			mov ecx, index;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	scr_anim_s Scr_GetAnim/*@<eax>*/(unsigned int index/*@<eax>*/, XAnimTree_s * a2/*@<ecx>*/, void* call_addr)
+	{
+		scr_anim_s answer;
+		
+		__asm
+		{
+			mov eax, index;
+			mov ecx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	float Scr_GetFloat/*@<xmm0>*/(scriptInstance_t inst/*@<eax>*/, unsigned int index/*@<ecx>*/, void* call_addr)
+	{
+		float answer;
+		
+		__asm
+		{
+			mov eax, inst;
+			mov ecx, index;
+			call call_addr;
+			movss answer, xmm0;
+		}
+		
+		return answer;
+	}
+
+	unsigned int Scr_GetConstString/*@<eax>*/(scriptInstance_t inst/*@<eax>*/, unsigned int index, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			push index;
+			mov eax, inst;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+		
+		return answer;
+	}
+
+	unsigned int Scr_GetConstLowercaseString/*@<eax>*/(scriptInstance_t inst/*@<ecx>*/, unsigned int index, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			push index;
+			mov ecx, inst;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x4;
+		}
+		
+		return answer;
+	}
+
+	const char * Scr_GetString/*@<eax>*/(unsigned int index/*@<eax>*/, scriptInstance_t inst/*@<esi>*/, void* call_addr)
+	{
+		const char * answer;
+		
+		__asm
+		{
+			mov eax, index;
+			mov esi, inst;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	unsigned int Scr_GetConstStringIncludeNull/*@<eax>*/(scriptInstance_t a1/*@<eax>*/, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	char * Scr_GetDebugString/*@<eax>*/(scriptInstance_t a1/*@<eax>*/, unsigned int a2/*@<ecx>*/, void* call_addr)
+	{
+		char * answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	unsigned int Scr_GetConstIString/*@<eax>*/(unsigned int index/*@<eax>*/, void* call_addr)
+	{
+		unsigned int answer;
+		
+		__asm
+		{
+			mov eax, index;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	void Scr_GetVector(scriptInstance_t inst/*@<eax>*/, float * value/*@<ecx>*/, unsigned int index, void* call_addr)
+	{
+		__asm
+		{
+			push index;
+			mov eax, inst;
+			mov ecx, value;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	scr_entref_t * Scr_GetEntityRef/*@<eax>*/(scriptInstance_t inst/*@<eax>*/, scr_entref_t * retstr, unsigned int index, void* call_addr)
+	{
+		scr_entref_t * answer;
+		
+		__asm
+		{
+			push index;
+			push retstr;
+			mov eax, inst;
+			call call_addr;
+			mov answer, eax;
+			add esp, 0x8;
+		}
+		
+		return answer;
+	}
+
+	VariableUnion Scr_GetObject/*@<eax>*/(scriptInstance_t a1/*@<eax>*/, void* call_addr)
+	{
+		VariableUnion answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	VariableType Scr_GetType/*@<eax>*/(scriptInstance_t inst/*@<eax>*/, unsigned int index/*@<ecx>*/, void* call_addr)
+	{
+		VariableType answer;
+		
+		__asm
+		{
+			mov eax, inst;
+			mov ecx, index;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	char * Scr_GetTypeName/*@<eax>*/(scriptInstance_t a1/*@<eax>*/, void* call_addr)
+	{
+		char * answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	VariableType Scr_GetPointerType/*@<eax>*/(scriptInstance_t a1/*@<eax>*/, unsigned int a2/*@<ecx>*/, void* call_addr)
+	{
+		VariableType answer;
+		
+		__asm
+		{
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			mov answer, eax;
+		}
+		
+		return answer;
+	}
+
+	void Scr_AddInt(scriptInstance_t inst/*@<eax>*/, int value, void* call_addr)
+	{
+		__asm
+		{
+			push value;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void Scr_AddFloat(scriptInstance_t inst/*@<eax>*/, float value, void* call_addr)
+	{
+		__asm
+		{
+			push value;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void Scr_AddUndefined(scriptInstance_t inst/*@<eax>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, inst;
+			call call_addr;
+		}
+	}
+
+	void Scr_AddObject(scriptInstance_t inst/*@<eax>*/, unsigned int entid/*@<esi>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, inst;
+			mov esi, entid;
+			call call_addr;
+		}
+	}
+
+	void Scr_AddString(scriptInstance_t inst/*@<eax>*/, const char * string, void* call_addr)
+	{
+		__asm
+		{
+			push string;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void Scr_AddIString(char * string/*@<esi>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov esi, string;
+			call call_addr;
+		}
+	}
+
+	void Scr_AddConstString(scriptInstance_t inst/*@<eax>*/, unsigned int id/*@<esi>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, inst;
+			mov esi, id;
+			call call_addr;
+		}
+	}
+
+	void Scr_AddVector(scriptInstance_t inst/*@<eax>*/, float * value, void* call_addr)
+	{
+		__asm
+		{
+			push value;
+			mov eax, inst;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void Scr_MakeArray(scriptInstance_t a1/*@<eax>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+		}
+	}
+
+	void Scr_AddArrayStringIndexed(unsigned int id/*@<ecx>*/, scriptInstance_t inst/*@<edi>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov ecx, id;
+			mov edi, inst;
+			call call_addr;
+		}
+	}
+
+	void Scr_Error(const char * err/*@<ecx>*/, scriptInstance_t inst/*@<edi>*/, int is_terminal, void* call_addr)
+	{
+		__asm
+		{
+			push is_terminal;
+			mov ecx, err;
+			mov edi, inst;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void Scr_TerminalError(scriptInstance_t a1/*@<eax>*/, const char * Source, void* call_addr)
+	{
+		__asm
+		{
+			push Source;
+			mov eax, a1;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void Scr_ParamError(int a1/*@<eax>*/, scriptInstance_t a2/*@<ecx>*/, const char * Source, void* call_addr)
+	{
+		__asm
+		{
+			push Source;
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void Scr_ObjectError(scriptInstance_t a1/*@<eax>*/, const char * a2/*@<ecx>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+		}
+	}
+
+	bool SetEntityFieldValue/*@<al>*/(scriptInstance_t inst/*@<edi>*/, int offset_/*@<eax>*/, int entnum/*@<ecx>*/, classNum_e classnum, int clientNum, VariableValue * value, void* call_addr)
+	{
+		bool answer;
+		
+		__asm
+		{
+			push value;
+			push clientNum;
+			push classnum;
+			mov edi, inst;
+			mov eax, offset_;
+			mov ecx, entnum;
+			call call_addr;
+			mov answer, al;
+			add esp, 0xC;
+		}
+		
+		return answer;
+	}
+
+	void Scr_SetStructField(unsigned int a1/*@<eax>*/, unsigned int a2/*@<ecx>*/, scriptInstance_t a3, void* call_addr)
+	{
+		__asm
+		{
+			push a3;
+			mov eax, a1;
+			mov ecx, a2;
+			call call_addr;
+			add esp, 0x4;
+		}
+	}
+
+	void Scr_IncTime(scriptInstance_t a1/*@<eax>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+		}
+	}
+
+	void Scr_RunCurrentThreads(scriptInstance_t a1/*@<esi>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov esi, a1;
+			call call_addr;
+		}
+	}
+
+	void Scr_ResetTimeout(scriptInstance_t a1/*@<eax>*/, void* call_addr)
+	{
+		__asm
+		{
+			mov eax, a1;
+			call call_addr;
+		}
+	}
+
+	void SetVariableFieldValue(scriptInstance_t inst, unsigned int id, VariableValue* value)
+	{
+		//cscr_vm::SetVariableFieldValue(inst, id, value);
+	}
+
+	void SetNewVariableValue(scriptInstance_t inst, unsigned int id, VariableValue* value)
+	{
+		//cscr_vm::SetNewVariableValue(inst, id, value);
+	}
+
+	void Scr_ClearErrorMessage(scriptInstance_t inst)
+	{
+		//cscr_vm::Scr_ClearErrorMessage(inst);
+	}
+
+	void VM_Shutdown(scriptInstance_t inst)
+	{
+		//cscr_vm::VM_Shutdown(inst);
+	}
+
+	void Scr_ShutdownVariables(scriptInstance_t inst)
+	{
+		//cscr_vm::Scr_ShutdownVariables(inst);
+	}
+
+	void ClearVariableValue(scriptInstance_t inst, unsigned int id)
+	{
+		//cscr_vm::ClearVariableValue(inst, id);
+	}
+
+	unsigned int Scr_GetThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId)
+	{
+		//return cscr_vm::Scr_GetThreadNotifyName(inst, startLocalId);
+		return 0;
+	}
+
+	void Scr_RemoveThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId)
+	{
+		//cscr_vm::Scr_RemoveThreadNotifyName(inst, startLocalId);
+	}
+
+	unsigned int GetArraySize(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_vm::GetArraySize(inst, id);
+		return 0;
+	}
+
+	void IncInParam(scriptInstance_t inst)
+	{
+		//cscr_vm::IncInParam(inst);
+	}
+
+	unsigned int GetParentLocalId(scriptInstance_t inst, unsigned int threadId)
+	{
+		//return cscr_vm::GetParentLocalId(inst, threadId);
+		return 0;
+	}
+
+	void Scr_ClearWaitTime(scriptInstance_t inst, unsigned int startLocalId)
+	{
+		//cscr_vm::Scr_ClearWaitTime(inst, startLocalId);
+	}
+
+	void Scr_SetThreadWaitTime(scriptInstance_t inst, unsigned int startLocalId, unsigned int waitTime)
+	{
+		//cscr_vm::Scr_SetThreadWaitTime(inst, startLocalId, waitTime);
+	}
+
+	void Scr_SetThreadNotifyName(scriptInstance_t inst, unsigned int startLocalId, unsigned int stringValue)
+	{
+		//cscr_vm::Scr_SetThreadNotifyName(inst, startLocalId, stringValue);
+	}
+
+	void Scr_DebugTerminateThread(scriptInstance_t inst, int topThread)
+	{
+		//cscr_vm::Scr_DebugTerminateThread(inst, topThread);
+	}
+
+	unsigned int Scr_GetThreadWaitTime(scriptInstance_t inst, unsigned int startLocalId)
+	{
+		//return cscr_vm::Scr_GetThreadWaitTime(inst, startLocalId);
+		return 0;
+	}
+
+	const char* Scr_GetStackThreadPos(scriptInstance_t inst, unsigned int endLocalId, VariableStackBuffer* stackValue, bool killThread)
+	{
+		//return cscr_vm::Scr_GetStackThreadPos(inst, endLocalId, stackValue, killThread);
+		return 0;
+	}
+
+	unsigned int Scr_GetSelf(scriptInstance_t inst, unsigned int threadId)
+	{
+		//return cscr_vm::Scr_GetSelf(inst, threadId);
+		return 0;
+	}
+
+	unsigned int GetVariableKeyObject(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_vm::GetVariableKeyObject(inst, id);
+		return 0;
+	}
+
+	int MT_Realloc(scriptInstance_t inst, int oldNumBytes, int newNumbytes)
+	{
+		//return cscr_vm::MT_Realloc(inst, oldNumBytes, newNumbytes);
+		return 0;
+	}
+
+	void CScr_GetObjectField(classNum_e classnum, int entnum, int clientNum, int offset)
+	{
+		//cscr_vm::CScr_GetObjectField(classnum, entnum, clientNum, offset);
+	}
+
+	int CScr_SetObjectField(classNum_e classnum, int entnum, int clientNum, int offset)
+	{
+		//return cscr_vm::CScr_SetObjectField(classnum, entnum, clientNum, offset);
+		return 0;
+	}
+
+	void Scr_SetErrorMessage(scriptInstance_t inst, const char* error)
+	{
+		//cscr_vm::Scr_SetErrorMessage(inst, error);
+	}
+
+	bool Scr_IsStackClear(scriptInstance_t inst)
+	{
+		//return cscr_vm::Scr_IsStackClear(inst);
+		return 0;
+	}
+
+	void SL_CheckExists(scriptInstance_t inst, unsigned int stringValue)
+	{
+		//cscr_vm::SL_CheckExists(inst, stringValue);
+	}
+
+	const char* Scr_ReadCodePos(scriptInstance_t inst, const char** pos)
+	{
+		//return cscr_vm::Scr_ReadCodePos(inst, pos);
+		return 0;
+	}
+
+	unsigned int Scr_ReadUnsignedInt(scriptInstance_t inst, const char** pos)
+	{
+		//return cscr_vm::Scr_ReadUnsignedInt(inst, pos);
+		return 0;
+	}
+
+	unsigned short Scr_ReadUnsignedShort(scriptInstance_t inst, const char** pos)
+	{
+		//return cscr_vm::Scr_ReadUnsignedShort(inst, pos);
+		return 0;
+	}
+
+	unsigned char Scr_ReadUnsignedByte(scriptInstance_t inst, const char** pos)
+	{
+		//return cscr_vm::Scr_ReadUnsignedByte(inst, pos);
+		return 0;
+	}
+
+	float Scr_ReadFloat(scriptInstance_t inst, const char** pos)
+	{
+		//return cscr_vm::Scr_ReadFloat(inst, pos);
+		return 0;
+	}
+
+	const float* Scr_ReadVector(scriptInstance_t inst, const char** pos)
+	{
+		//return cscr_vm::Scr_ReadVector(inst, pos);
+		return 0;
+	}
+
+	BOOL IsFieldObject(scriptInstance_t inst, unsigned int id)
+	{
+		//return cscr_vm::IsFieldObject(inst, id);
+		return 0;
+	}
+
+	void RemoveVariableValue(scriptInstance_t inst, unsigned int parentId, unsigned int index)
+	{
+		//cscr_vm::RemoveVariableValue(inst, parentId, index);
+	}
+
+	VariableStackBuffer* GetRefVariableStackBuffer(scriptInstance_t inst, int id)
+	{
+		//return cscr_vm::GetRefVariableStackBuffer(inst, id);
+		return 0;
+	}
+
+	unsigned int GetNewVariableIndexReverseInternal(scriptInstance_t inst, unsigned int parentId, unsigned int name)
+	{
+		//return cscr_vm::GetNewVariableIndexReverseInternal(inst, parentId, name);
+		return 0;
+	}
+
+	unsigned int GetNewObjectVariableReverse(scriptInstance_t inst, unsigned int parentId, unsigned int id)
+	{
+		//return cscr_vm::GetNewObjectVariableReverse(inst, parentId, id);
+		return 0;
+	}
+
+	unsigned int Scr_GetLocalVar(scriptInstance_t inst, int pos)
+	{
+		//return cscr_vm::Scr_GetLocalVar(inst, pos);
+		return 0;
+	}
+
+	void Scr_EvalBoolNot(scriptInstance_t inst, VariableValue* value)
+	{
+		//cscr_vm::Scr_EvalBoolNot(inst, value);
+	}
+
+	unsigned int GetInternalVariableIndex(scriptInstance_t inst, unsigned int unsignedValue)
+	{
+		//return cscr_vm::GetInternalVariableIndex(inst, unsignedValue);
+		return 0;
+	}
+
+	const char* Scr_ReadData(scriptInstance_t inst, const char** pos, unsigned int count)
+	{
+		//return cscr_vm::Scr_ReadData(inst, pos, count);
+		return 0;
+	}
+}
\ No newline at end of file
diff --git a/src/game/structs.hpp b/src/game/structs.hpp
index 5bfce1d..ff7b5fc 100644
--- a/src/game/structs.hpp
+++ b/src/game/structs.hpp
@@ -7008,31 +7008,6 @@ namespace game
 	ASSERT_STRUCT_OFFSET(entityHandler_t, methodOfDeath, 0x24);
 	ASSERT_STRUCT_OFFSET(entityHandler_t, splashMethodOfDeath, 0x28);
 
-	struct yy_buffer_state
-	{
-		_iobuf * yy_input_file; //OFS: 0x0 SIZE: 0x4
-		char * yy_ch_buf; //OFS: 0x4 SIZE: 0x4
-		char * yy_buf_pos; //OFS: 0x8 SIZE: 0x4
-		unsigned int yy_buf_size; //OFS: 0xC SIZE: 0x4
-		int yy_n_chars; //OFS: 0x10 SIZE: 0x4
-		int yy_is_our_buffer; //OFS: 0x14 SIZE: 0x4
-		int yy_is_interactive; //OFS: 0x18 SIZE: 0x4
-		int yy_at_bol; //OFS: 0x1C SIZE: 0x4
-		int yy_fill_buffer; //OFS: 0x20 SIZE: 0x4
-		int yy_buffer_status; //OFS: 0x24 SIZE: 0x4
-	};
-	ASSERT_STRUCT_SIZE(yy_buffer_state, 0x28);
-	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_input_file, 0x0);
-	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_ch_buf, 0x4);
-	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buf_pos, 0x8);
-	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buf_size, 0xC);
-	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_n_chars, 0x10);
-	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_is_our_buffer, 0x14);
-	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_is_interactive, 0x18);
-	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_at_bol, 0x1C);
-	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_fill_buffer, 0x20);
-	ASSERT_STRUCT_OFFSET(yy_buffer_state, yy_buffer_status, 0x24);
-
 	struct CmdArgsPrivate
 	{
 		char textPool[8192]; //OFS: 0x0 SIZE: 0x2000
@@ -11255,15 +11230,6 @@ namespace game
 	ASSERT_STRUCT_OFFSET(struct_0, var_34, 0x14);
 	ASSERT_STRUCT_OFFSET(struct_0, var_30, 0x18);
 
-	struct stype_t
-	{
-		sval_u val; //OFS: 0x0 SIZE: 0x4
-		unsigned int pos; //OFS: 0x4 SIZE: 0x4
-	};
-	ASSERT_STRUCT_SIZE(stype_t, 0x8);
-	ASSERT_STRUCT_OFFSET(stype_t, val, 0x0);
-	ASSERT_STRUCT_OFFSET(stype_t, pos, 0x4);
-
 	struct DObjModel_s
 	{
 		XModel * model; //OFS: 0x0 SIZE: 0x4
diff --git a/src/stdinc.hpp b/src/stdinc.hpp
index c685fcd..ec291d4 100644
--- a/src/stdinc.hpp
+++ b/src/stdinc.hpp
@@ -9,7 +9,9 @@
 
 #pragma warning(disable: 4324)
 #pragma warning(disable: 4459)
-#pragma warning(once: 26493)
+#pragma warning(error: 4409)
+
+#pragma warning(disable: 4100) // remove when decomp is imported
 
 #define DLL_EXPORT extern "C" __declspec(dllexport)
 #define WIN32_LEAN_AND_MEAN