From 41b6f6bd4a7a4d73242b0ba5665e80f41742839d Mon Sep 17 00:00:00 2001
From: David Anderson <dvander@alliedmods.net>
Date: Tue, 5 Oct 2004 07:17:49 +0000
Subject: [PATCH] Initial import (untested!)

---
 dlls/regex/CRegEx.cpp            |  112 ++
 dlls/regex/CRegEx.h              |   26 +
 dlls/regex/CVector.h             |  444 +++++
 dlls/regex/amxxmodule.cpp        | 3042 ++++++++++++++++++++++++++++++
 dlls/regex/amxxmodule.h          | 2197 +++++++++++++++++++++
 dlls/regex/lib_win/pcre.lib      |  Bin 0 -> 120740 bytes
 dlls/regex/lib_win/pcreposix.lib |  Bin 0 -> 26892 bytes
 dlls/regex/module.cpp            |  104 +
 dlls/regex/module.h              |   10 +
 dlls/regex/moduleconfig.h        |  462 +++++
 dlls/regex/pcre.h                |  193 ++
 11 files changed, 6590 insertions(+)
 create mode 100755 dlls/regex/CRegEx.cpp
 create mode 100755 dlls/regex/CRegEx.h
 create mode 100755 dlls/regex/CVector.h
 create mode 100755 dlls/regex/amxxmodule.cpp
 create mode 100755 dlls/regex/amxxmodule.h
 create mode 100755 dlls/regex/lib_win/pcre.lib
 create mode 100755 dlls/regex/lib_win/pcreposix.lib
 create mode 100755 dlls/regex/module.cpp
 create mode 100755 dlls/regex/module.h
 create mode 100755 dlls/regex/moduleconfig.h
 create mode 100755 dlls/regex/pcre.h

diff --git a/dlls/regex/CRegEx.cpp b/dlls/regex/CRegEx.cpp
new file mode 100755
index 00000000..7dacb81f
--- /dev/null
+++ b/dlls/regex/CRegEx.cpp
@@ -0,0 +1,112 @@
+#include "pcre.h"
+#include "CRegEx.h"
+#include <string.h>
+
+RegEx::RegEx()
+{
+	mErrorOffset = 0;
+	mError = NULL;
+	re = NULL;
+	mFree = true;
+	subject = NULL;
+	mSubStrings = 0;
+}
+
+void RegEx::Clear()
+{
+	mErrorOffset = 0;
+	mError = NULL;
+	if (re)
+		pcre_free(re);
+	re = NULL;
+	mFree = true;
+	if (subject)
+		delete [] subject;
+	subject = NULL;
+	mSubStrings = 0;
+}
+
+RegEx::~RegEx()
+{
+	Clear();
+}
+
+bool RegEx::isFree(bool set, bool val)
+{
+	if (set)
+	{
+		mFree = val;
+		return true;
+	} else {
+		return mFree;
+	}
+}
+
+int RegEx::Compile(const char *pattern)
+{
+	int errno;
+
+	if (!mFree)
+		Clear();
+
+	re = pcre_compile(pattern, 0, &mError, &mErrorOffset, NULL);
+
+	if (re == NULL)
+	{
+		return 0;
+	}
+
+	mFree = false;
+
+	return 1;
+}
+
+int RegEx::Match(const char *str)
+{
+	int rc = 0;
+
+	if (mFree || re == NULL)
+		return -1;
+
+	//save str
+	subject = new char[strlen(str)+1];
+	strcpy(subject, str);
+
+	rc = pcre_exec(re, NULL, subject, (int)strlen(subject), 0, 0, ovector, 30);
+
+	if (rc < 0)
+	{
+		if (rc == PCRE_ERROR_NOMATCH)
+		{
+			return 0;
+		} else {
+			mErrorOffset = rc;
+			return -1;
+		}
+	}
+
+	mSubStrings = rc;
+
+	return 1;
+}
+
+const char *RegEx::GetSubstring(int s, char buffer[], int max)
+{
+	if (s >= mSubStrings || s < 0)
+		return NULL;
+
+	char *substr_a = subject + ovector[2*s];
+	int substr_l = ovector[2*s+1] - ovector[2*s];
+
+	for (int i = 0; i<substr_l; i++)
+	{
+		if (i >= max)
+			break;
+		buffer[i] = substr_a[i];
+	}
+
+	buffer[i] = '\0';
+
+	return buffer;
+}
+
diff --git a/dlls/regex/CRegEx.h b/dlls/regex/CRegEx.h
new file mode 100755
index 00000000..6a7d023b
--- /dev/null
+++ b/dlls/regex/CRegEx.h
@@ -0,0 +1,26 @@
+#ifndef _INCLUDE_CREGEX_H
+#define _INCLUDE_CREGEX_H
+
+class RegEx
+{
+public:
+	RegEx();
+	~RegEx();
+	bool isFree(bool set=false, bool val=false);
+	void Clear();
+
+	int Compile(const char *pattern);
+	int Match(const char *str);
+	const char *GetSubstring(int s, char buffer[], int max);
+public:
+	int mErrorOffset;
+	const char *mError;
+	int mSubStrings;
+private:
+	pcre *re;
+	bool mFree;
+	int ovector[30];
+	char *subject;
+};
+
+#endif //_INCLUDE_CREGEX_H
\ No newline at end of file
diff --git a/dlls/regex/CVector.h b/dlls/regex/CVector.h
new file mode 100755
index 00000000..05538f53
--- /dev/null
+++ b/dlls/regex/CVector.h
@@ -0,0 +1,444 @@
+/* AMX Mod X
+*
+* by the AMX Mod X Development Team
+*  originally developed by OLO
+*
+*
+*  This program is free software; you can redistribute it and/or modify it
+*  under the terms of the GNU General Public License as published by the
+*  Free Software Foundation; either version 2 of the License, or (at
+*  your option) any later version.
+*
+*  This program is distributed in the hope that it will be useful, but
+*  WITHOUT ANY WARRANTY; without even the implied warranty of
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+*  General Public License for more details.
+*
+*  You should have received a copy of the GNU General Public License
+*  along with this program; if not, write to the Free Software Foundation,
+*  Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*
+*  In addition, as a special exception, the author gives permission to
+*  link the code of this program with the Half-Life Game Engine ("HL
+*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
+*  L.L.C ("Valve"). You must obey the GNU General Public License in all
+*  respects for all of the code used other than the HL Engine and MODs
+*  from Valve. If you modify this file, you may extend this exception
+*  to your version of the file, but you are not obligated to do so. If
+*  you do not wish to do so, delete this exception statement from your
+*  version.
+*/
+
+#ifndef __CVECTOR_H__
+#define __CVECTOR_H__
+
+#include <assert.h>
+
+// Vector
+template <class T> class CVector
+{
+	bool Grow()
+	{
+		// automatic grow
+		size_t newSize = m_Size * 2;
+		if (newSize == 0)
+			newSize = 8;					// a good init value
+		T *newData = new T[newSize];
+		if (!newData)
+			return false;
+		if (m_Data)
+		{
+			memcpy(newData, m_Data, m_Size * sizeof(T));
+			delete [] m_Data;
+		}
+		m_Data = newData;
+		m_Size = newSize;
+		return true;
+	}
+
+	bool GrowIfNeeded()
+	{
+		if (m_CurrentUsedSize >= m_Size)
+			return Grow();
+		else
+			return true;
+	}
+
+	bool ChangeSize(size_t size)
+	{
+		// change size
+		if (size == m_Size)
+			return true;
+		T *newData = new T[size];
+		if (!newData)
+			return false;
+		if (m_Data)
+		{
+			memcpy(newData, m_Data, (m_Size < size) ? (m_Size * sizeof(T)) : (size * sizeof(T)));
+			delete [] m_Data;
+		}
+		if (m_Size < size)
+			m_CurrentSize = size;
+		m_Data = newData;
+		m_Size = size;
+		return true;
+	}
+
+	void FreeMemIfPossible()
+	{
+
+	}
+protected:
+	T *m_Data;
+	size_t m_Size;
+	size_t m_CurrentUsedSize;
+	size_t m_CurrentSize;
+public:
+	class iterator
+	{
+	protected:
+		T *m_Ptr;
+	public:
+		// constructors / destructors
+		iterator()
+		{
+			m_Ptr = NULL;
+		}
+
+		iterator(T * ptr)
+		{
+			m_Ptr = ptr;
+		}
+
+		// member functions
+		T * base()
+		{
+			return m_Ptr;
+		}
+
+		const T * base() const
+		{
+			return m_Ptr;
+		}
+
+		// operators
+		T & operator*()
+		{
+			return *m_Ptr;
+		}
+
+		T * operator->()
+		{
+			return m_Ptr;
+		}
+
+		iterator & operator++()		// preincrement
+		{
+			++m_Ptr;
+			return (*this);
+		}
+
+		iterator operator++(int)	// postincrement
+		{
+			iterator tmp = *this;
+			++m_Ptr;
+			return tmp;
+		}
+
+		iterator & operator--()		// predecrement
+		{
+			--m_Ptr;
+			return (*this);
+		}
+
+		iterator operator--(int)	// postdecrememnt
+		{
+			iterator tmp = *this;
+			--m_Ptr;
+			return tmp;
+		}
+
+		bool operator==(T * right) const
+		{
+			return (m_Ptr == right);
+		}
+
+		bool operator==(const iterator & right) const
+		{
+			return (m_Ptr == right.m_Ptr);
+		}
+
+		bool operator!=(T * right) const
+		{
+			return (m_Ptr != right);
+		}
+
+		bool operator!=(const iterator & right) const
+		{
+			return (m_Ptr != right.m_Ptr);
+		}
+
+		iterator & operator+=(size_t offset)
+		{
+			m_Ptr += offset;
+			return (*this);
+		}
+
+		iterator & operator-=(size_t offset)
+		{
+			m_Ptr += offset;
+			return (*this);
+		}
+
+		iterator operator+(size_t offset) const
+		{
+			iterator tmp(*this);
+			tmp.m_Ptr += offset;
+			return tmp;
+		}
+
+		iterator operator-(size_t offset) const
+		{
+			iterator tmp(*this);
+			tmp.m_Ptr += offset;
+			return tmp;
+		}
+		
+		T & operator[](size_t offset)
+		{
+			return (*(*this + offset));
+		}
+
+		const T & operator[](size_t offset) const
+		{
+			return (*(*this + offset));
+		}
+
+		bool operator<(const iterator & right) const
+		{
+			return m_Ptr < right.m_Ptr;
+		}
+
+		bool operator>(const iterator & right) const
+		{
+			return m_Ptr > right.m_Ptr;
+		}
+
+		bool operator<=(const iterator & right) const
+		{
+			return m_Ptr <= right.m_Ptr;
+		}
+
+		bool operator>=(const iterator & right) const
+		{
+			return m_Ptr >= right.m_Ptr;
+		}
+
+		size_t operator-(const iterator & right) const
+		{
+			return m_Ptr - right.m_Ptr;
+		}
+	};
+
+	// constructors / destructors
+	CVector<T>()
+	{
+		m_Size = 0;
+		m_CurrentUsedSize = 0;
+		m_Data = NULL;
+	}
+
+	CVector<T>(const CVector<T> & other)
+	{
+		// copy data
+		m_Data = new T [other.m_Size];
+		m_Size = other.m_Size;
+		m_CurrentUsedSize = other.m_CurrentUsedSize;
+		memcpy(m_Data, other.m_Data, m_CurrentUsedSize * sizeof(T));
+	}
+
+	~CVector<T>()
+	{
+		clear();
+	}
+
+	// interface
+	size_t size() const
+	{
+		return m_CurrentUsedSize;
+	}
+
+	size_t capacity() const
+	{
+		return m_Size;
+	}
+
+	iterator begin()
+	{
+		return iterator(m_Data);
+	}
+
+	iterator end()
+	{
+		return iterator(m_Data + m_CurrentUsedSize);
+	}
+
+	iterator iterAt(size_t pos)
+	{
+		if (pos > m_CurrentUsedSize)
+			assert(0);
+		return iterator(m_Data + pos);
+	}
+
+	bool reserve(size_t newSize)
+	{
+		return ChangeSize(newSize);
+	}
+
+	bool push_back(const T & elem)
+	{
+		++m_CurrentUsedSize;
+		if (!GrowIfNeeded())
+		{
+			--m_CurrentUsedSize;
+			return false;
+		}
+
+		m_Data[m_CurrentUsedSize - 1] = elem;
+		return true;
+	}
+
+	void pop_back()
+	{
+		--m_CurrentUsedSize;
+		if (m_CurrentUsedSize < 0)
+			m_CurrentUsedSize = 0;
+		// :TODO: free memory sometimes
+	}
+
+	bool resize(size_t newSize)
+	{
+		if (!ChangeSize(newSize))
+			return false;
+		FreeMemIfPossible();
+		return true;
+	}
+
+	bool empty() const
+	{
+		return (m_CurrentUsedSize == 0);
+	}
+
+	T & at(size_t pos)
+	{
+		if (pos > m_CurrentUsedSize)
+		{
+			assert(0);
+		}
+		return m_Data[pos];
+	}
+
+	const  T & at(size_t pos) const
+	{
+		if (pos > m_CurrentUsedSize)
+		{
+			assert(0);
+		}
+		return m_Data[pos];
+	}
+
+	T & operator[](size_t pos)
+	{
+		return at(pos);
+	}
+
+	const T & operator[](size_t pos) const
+	{
+		return at(pos);
+	}
+
+	T & front()
+	{
+		if (m_CurrentUsedSize < 1)
+		{
+			assert(0);
+		}
+		return m_Data[0];
+	}
+
+	const T & front() const
+	{
+		if (m_CurrentUsedSize < 1)
+		{
+			assert(0);
+		}
+		return m_Data[0];
+	}
+
+	T & back()
+	{
+		if (m_CurrentUsedSize < 1)
+		{
+			assert(0);
+		}
+		return m_Data[m_CurrentUsedSize - 1];
+	}
+
+	const T & back() const
+	{
+		if (m_CurrentUsedSize < 1)
+		{
+			assert(0);
+		}
+		return m_Data[m_CurrentUsedSize - 1];
+	}
+
+	bool insert(iterator where, const T & value)
+	{
+		// we have to insert before
+		// if it is begin, don't decrement
+		if (where != m_Data)
+			--where;
+		// validate iter
+		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
+			return false;
+
+		++m_CurrentUsedSize;
+		if (!GrowIfNeeded())
+		{
+			--m_CurrentUsedSize;
+			return false;
+		}
+
+		memmove(where.base() + 1, where.base(), m_CurrentUsedSize - (where - m_Data));
+		memcpy(where.base(), &value, sizeof(T));
+		return true;
+	}
+
+	void erase(iterator where)
+	{
+		// validate iter
+		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
+			return false;
+
+		if (m_CurrentUsedSize > 1)
+		{
+			// move
+			memmove(where.base(), where.base() + 1, m_CurrentUsedSize - 1);
+		}
+
+		--m_CurrentUsedSize;
+		// :TODO: free memory sometimes
+	}
+
+	void clear()
+	{
+		m_Size = 0;
+		m_CurrentUsedSize = 0;
+		delete [] m_Data;
+		m_Data = NULL;
+	}
+};
+
+#endif // __CVECTOR_H__
+
diff --git a/dlls/regex/amxxmodule.cpp b/dlls/regex/amxxmodule.cpp
new file mode 100755
index 00000000..9f4e7ebb
--- /dev/null
+++ b/dlls/regex/amxxmodule.cpp
@@ -0,0 +1,3042 @@
+/* AMX Mod X
+*
+* by the AMX Mod X Development Team
+*  originally developed by OLO
+*
+* Parts Copyright (C) 2001-2003 Will Day <willday@hpgx.net>
+*
+*  This program is free software; you can redistribute it and/or modify it
+*  under the terms of the GNU General Public License as published by the
+*  Free Software Foundation; either version 2 of the License, or (at
+*  your option) any later version.
+*
+*  This program is distributed in the hope that it will be useful, but
+*  WITHOUT ANY WARRANTY; without even the implied warranty of
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+*  General Public License for more details.
+*
+*  You should have received a copy of the GNU General Public License
+*  along with this program; if not, write to the Free Software Foundation,
+*  Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*
+*  In addition, as a special exception, the author gives permission to
+*  link the code of this program with the Half-Life Game Engine ("HL
+*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
+*  L.L.C ("Valve"). You must obey the GNU General Public License in all
+*  respects for all of the code used other than the HL Engine and MODs
+*  from Valve. If you modify this file, you may extend this exception
+*  to your version of the file, but you are not obligated to do so. If
+*  you do not wish to do so, delete this exception statement from your
+*  version.
+*
+*  Description: AMX Mod X Module Interface Functions
+*/
+
+#include <string.h>
+#include <new>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "amxxmodule.h"
+
+/************* METAMOD SUPPORT *************/
+#ifdef USE_METAMOD
+
+enginefuncs_t g_engfuncs;
+globalvars_t  *gpGlobals;
+
+
+
+DLL_FUNCTIONS *g_pFunctionTable;
+DLL_FUNCTIONS *g_pFunctionTable_Post;
+enginefuncs_t *g_pengfuncsTable;
+enginefuncs_t *g_pengfuncsTable_Post;
+NEW_DLL_FUNCTIONS *g_pNewFunctionsTable;
+NEW_DLL_FUNCTIONS *g_pNewFunctionsTable_Post;
+
+
+// GetEntityAPI2 functions
+static DLL_FUNCTIONS g_EntityAPI_Table = 
+{
+#ifdef FN_GameDLLInit
+	FN_GameDLLInit,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchSpawn
+	FN_DispatchSpawn,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchThink
+	FN_DispatchThink,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchUse
+	FN_DispatchUse,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchTouch
+	FN_DispatchTouch,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchBlocked
+	FN_DispatchBlocked,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchKeyValue
+	FN_DispatchKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchSave
+	FN_DispatchSave,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchRestore
+	FN_DispatchRestore,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchObjectCollsionBox
+	FN_DispatchObjectCollsionBox,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveWriteFields
+	FN_SaveWriteFields,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveReadFields
+	FN_SaveReadFields,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveGlobalState
+	FN_SaveGlobalState,
+#else
+	NULL,
+#endif
+#ifdef FN_RestoreGlobalState
+	FN_RestoreGlobalState,
+#else
+	NULL,
+#endif
+#ifdef FN_ResetGlobalState
+	FN_ResetGlobalState,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientConnect
+	FN_ClientConnect,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientDisconnect
+	FN_ClientDisconnect,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientKill
+	FN_ClientKill,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientPutInServer
+	FN_ClientPutInServer,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientCommand
+	FN_ClientCommand,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientUserInfoChanged
+	FN_ClientUserInfoChanged,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerActivate
+	FN_ServerActivate,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerDeactivate
+	FN_ServerDeactivate,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerPreThink
+	FN_PlayerPreThink,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerPostThink
+	FN_PlayerPostThink,
+#else
+	NULL,
+#endif
+#ifdef FN_StartFrame
+	FN_StartFrame,
+#else
+	NULL,
+#endif
+#ifdef FN_ParmsNewLevel
+	FN_ParmsNewLevel,
+#else
+	NULL,
+#endif
+#ifdef FN_ParmsChangeLevel
+	FN_ParmsChangeLevel,
+#else
+	NULL,
+#endif
+#ifdef FN_GetGameDescription
+	FN_GetGameDescription,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerCustomization
+	FN_PlayerCustomization,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorConnect
+	FN_SpectatorConnect,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorDisconnect
+	FN_SpectatorDisconnect,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorThink
+	FN_SpectatorThink,
+#else
+	NULL,
+#endif
+#ifdef FN_Sys_Error
+	FN_Sys_Error,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_Move
+	FN_PM_Move,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_Init
+	FN_PM_Init,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_FindTextureType
+	FN_PM_FindTextureType,
+#else
+	NULL,
+#endif
+#ifdef FN_SetupVisibility
+	FN_SetupVisibility,
+#else
+	NULL,
+#endif
+#ifdef FN_UpdateClientData
+	FN_UpdateClientData,
+#else
+	NULL,
+#endif
+#ifdef FN_AddToFullPack
+	FN_AddToFullPack,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateBaseline
+	FN_CreateBaseline,
+#else
+	NULL,
+#endif
+#ifdef FN_RegisterEncoders
+	FN_RegisterEncoders,
+#else
+	NULL,
+#endif
+#ifdef FN_GetWeaponData
+	FN_GetWeaponData,
+#else
+	NULL,
+#endif
+#ifdef FN_CmdStart
+	FN_CmdStart,
+#else
+	NULL,
+#endif
+#ifdef FN_CmdEnd
+	FN_CmdEnd,
+#else
+	NULL,
+#endif
+#ifdef FN_ConnectionlessPacket
+	FN_ConnectionlessPacket,
+#else
+	NULL,
+#endif
+#ifdef FN_GetHullBounds
+	FN_GetHullBounds,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateInstancedBaselines
+	FN_CreateInstancedBaselines,
+#else
+	NULL,
+#endif
+#ifdef FN_InconsistentFile
+	FN_InconsistentFile,
+#else
+	NULL,
+#endif
+#ifdef FN_AllowLagCompensation
+	FN_AllowLagCompensation
+#else
+	NULL
+#endif
+}; // g_EntityAPI2_Table
+
+// GetEntityAPI2_Post functions
+static DLL_FUNCTIONS g_EntityAPI_Post_Table = 
+{
+#ifdef FN_GameDLLInit_Post
+	FN_GameDLLInit_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchSpawn_Post
+	FN_DispatchSpawn_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchThink_Post
+	FN_DispatchThink_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchUse_Post
+	FN_DispatchUse_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchTouch_Post
+	FN_DispatchTouch_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchBlocked_Post
+	FN_DispatchBlocked_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchKeyValue_Post
+	FN_DispatchKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchSave_Post
+	FN_DispatchSave_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchRestore_Post
+	FN_DispatchRestore_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchObjectCollsionBox_Post
+	FN_DispatchObjectCollsionBox_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveWriteFields_Post
+	FN_SaveWriteFields_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveReadFields_Post
+	FN_SaveReadFields_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveGlobalState_Post
+	FN_SaveGlobalState_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RestoreGlobalState_Post
+	FN_RestoreGlobalState_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ResetGlobalState_Post
+	FN_ResetGlobalState_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientConnect_Post
+	FN_ClientConnect_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientDisconnect_Post
+	FN_ClientDisconnect_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientKill_Post
+	FN_ClientKill_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientPutInServer_Post
+	FN_ClientPutInServer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientCommand_Post
+	FN_ClientCommand_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientUserInfoChanged_Post
+	FN_ClientUserInfoChanged_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerActivate_Post
+	FN_ServerActivate_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerDeactivate_Post
+	FN_ServerDeactivate_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerPreThink_Post
+	FN_PlayerPreThink_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerPostThink_Post
+	FN_PlayerPostThink_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_StartFrame_Post
+	FN_StartFrame_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ParmsNewLevel_Post
+	FN_ParmsNewLevel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ParmsChangeLevel_Post
+	FN_ParmsChangeLevel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetGameDescription_Post
+	FN_GetGameDescription_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerCustomization_Post
+	FN_PlayerCustomization_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorConnect_Post
+	FN_SpectatorConnect_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorDisconnect_Post
+	FN_SpectatorDisconnect_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorThink_Post
+	FN_SpectatorThink_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Sys_Error_Post
+	FN_Sys_Error_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_Move_Post
+	FN_PM_Move_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_Init_Post
+	FN_PM_Init_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_FindTextureType_Post
+	FN_PM_FindTextureType_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetupVisibility_Post
+	FN_SetupVisibility_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_UpdateClientData_Post
+	FN_UpdateClientData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AddToFullPack_Post
+	FN_AddToFullPack_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateBaseline_Post
+	FN_CreateBaseline_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RegisterEncoders_Post
+	FN_RegisterEncoders_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetWeaponData_Post
+	FN_GetWeaponData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CmdStart_Post
+	FN_CmdStart_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CmdEnd_Post
+	FN_CmdEnd_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ConnectionlessPacket_Post
+	FN_ConnectionlessPacket_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetHullBounds_Post
+	FN_GetHullBounds_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateInstancedBaselines_Post
+	FN_CreateInstancedBaselines_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_InconsistentFile_Post
+	FN_InconsistentFile_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AllowLagCompensation
+	FN_AllowLagCompensation,
+#else
+	NULL,
+#endif
+}; // g_EntityAPI2_Table
+
+static enginefuncs_t g_EngineFuncs_Table = 
+{
+#ifdef FN_PrecacheModel
+	FN_PrecacheModel,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheSound
+	FN_PrecacheSound,
+#else
+	NULL,
+#endif
+#ifdef FN_SetModel
+	FN_SetModel,
+#else
+	NULL,
+#endif
+#ifdef FN_ModelIndex
+	FN_ModelIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_ModelFrames
+	FN_ModelFrames,
+#else
+	NULL,
+#endif
+#ifdef FN_SetSize
+	FN_SetSize,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangeLevel
+	FN_ChangeLevel,
+#else
+	NULL,
+#endif
+#ifdef FN_GetSpawnParms
+	FN_GetSpawnParms,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveSpawnParms
+	FN_SaveSpawnParms,
+#else
+	NULL,
+#endif
+#ifdef FN_VecToYaw
+	FN_VecToYaw,
+#else
+	NULL,
+#endif
+#ifdef FN_VecToAngles
+	FN_VecToAngles,
+#else
+	NULL,
+#endif
+#ifdef FN_MoveToOrigin
+	FN_MoveToOrigin,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangeYaw
+	FN_ChangeYaw,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangePitch
+	FN_ChangePitch,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityByString
+	FN_FindEntityByString,
+#else
+	NULL,
+#endif
+#ifdef FN_GetEntityIllum
+	FN_GetEntityIllum,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityInSphere
+	FN_FindEntityInSphere,
+#else
+	NULL,
+#endif
+#ifdef FN_FindClientInPVS
+	FN_FindClientInPVS,
+#else
+	NULL,
+#endif
+#ifdef FN_EntitiesInPVS
+	FN_EntitiesInPVS,
+#else
+	NULL,
+#endif
+#ifdef FN_MakeVectors
+	FN_MakeVectors,
+#else
+	NULL,
+#endif
+#ifdef FN_AngleVectors
+	FN_AngleVectors,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateEntity
+	FN_CreateEntity,
+#else
+	NULL,
+#endif
+#ifdef FN_RemoveEntity
+	FN_RemoveEntity,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateNamedEntity
+	FN_CreateNamedEntity,
+#else
+	NULL,
+#endif
+#ifdef FN_MakeStatic
+	FN_MakeStatic,
+#else
+	NULL,
+#endif
+#ifdef FN_EntIsOnFloor
+	FN_EntIsOnFloor,
+#else
+	NULL,
+#endif
+#ifdef FN_DropToFloor
+	FN_DropToFloor,
+#else
+	NULL,
+#endif
+#ifdef FN_WalkMove
+	FN_WalkMove,
+#else
+	NULL,
+#endif
+#ifdef FN_SetOrigin
+	FN_SetOrigin,
+#else
+	NULL,
+#endif
+#ifdef FN_EmitSound
+	FN_EmitSound,
+#else
+	NULL,
+#endif
+#ifdef FN_EmitAmbientSound
+	FN_EmitAmbientSound,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceLine
+	FN_TraceLine,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceToss
+	FN_TraceToss,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceMonsterHull
+	FN_TraceMonsterHull,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceHull
+	FN_TraceHull,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceModel
+	FN_TraceModel,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceTexture
+	FN_TraceTexture,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceSphere
+	FN_TraceSphere,
+#else
+	NULL,
+#endif
+#ifdef FN_GetAimVector
+	FN_GetAimVector,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerCommand
+	FN_ServerCommand,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerExecute
+	FN_ServerExecute,
+#else
+	NULL,
+#endif
+#ifdef FN_engClientCommand
+	FN_engClientCommand,
+#else
+	NULL,
+#endif
+#ifdef FN_ParticleEffect
+	FN_ParticleEffect,
+#else
+	NULL,
+#endif
+#ifdef FN_LightStyle
+	FN_LightStyle,
+#else
+	NULL,
+#endif
+#ifdef FN_DecalIndex
+	FN_DecalIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_PointContents
+	FN_PointContents,
+#else
+	NULL,
+#endif
+#ifdef FN_MessageBegin
+	FN_MessageBegin,
+#else
+	NULL,
+#endif
+#ifdef FN_MessageEnd
+	FN_MessageEnd,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteByte
+	FN_WriteByte,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteChar
+	FN_WriteChar,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteShort
+	FN_WriteShort,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteLong
+	FN_WriteLong,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteAngle
+	FN_WriteAngle,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteCoord
+	FN_WriteCoord,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteString
+	FN_WriteString,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteEntity
+	FN_WriteEntity,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarRegister
+	FN_CVarRegister,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetFloat
+	FN_CVarGetFloat,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetString
+	FN_CVarGetString,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarSetFloat
+	FN_CVarSetFloat,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarSetString
+	FN_CVarSetString,
+#else
+	NULL,
+#endif
+#ifdef FN_AlertMessage
+	FN_AlertMessage,
+#else
+	NULL,
+#endif
+#ifdef FN_EngineFprintf
+	FN_EngineFprintf,
+#else
+	NULL,
+#endif
+#ifdef FN_PvAllocEntPrivateData
+	FN_PvAllocEntPrivateData,
+#else
+	NULL,
+#endif
+#ifdef FN_PvEntPrivateData
+	FN_PvEntPrivateData,
+#else
+	NULL,
+#endif
+#ifdef FN_FreeEntPrivateData
+	FN_FreeEntPrivateData,
+#else
+	NULL,
+#endif
+#ifdef FN_SzFromIndex
+	FN_SzFromIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_AllocString
+	FN_AllocString,
+#else
+	NULL,
+#endif
+#ifdef FN_GetVarsOfEnt
+	FN_GetVarsOfEnt,
+#else
+	NULL,
+#endif
+#ifdef FN_PEntityOfEntOffset
+	FN_PEntityOfEntOffset,
+#else
+	NULL,
+#endif
+#ifdef FN_EntOffsetOfPEntity
+	FN_EntOffsetOfPEntity,
+#else
+	NULL,
+#endif
+#ifdef FN_IndexOfEdict
+	FN_IndexOfEdict,
+#else
+	NULL,
+#endif
+#ifdef FN_PEntityOfEntIndex
+	FN_PEntityOfEntIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityByVars
+	FN_FindEntityByVars,
+#else
+	NULL,
+#endif
+#ifdef FN_GetModelPtr
+	FN_GetModelPtr,
+#else
+	NULL,
+#endif
+#ifdef FN_RegUserMsg
+	FN_RegUserMsg,
+#else
+	NULL,
+#endif
+#ifdef FN_AnimationAutomove
+	FN_AnimationAutomove,
+#else
+	NULL,
+#endif
+#ifdef FN_GetBonePosition
+	FN_GetBonePosition,
+#else
+	NULL,
+#endif
+#ifdef FN_FunctionFromName
+	FN_FunctionFromName,
+#else
+	NULL,
+#endif
+#ifdef FN_NameForFunction
+	FN_NameForFunction,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientPrintf
+	FN_ClientPrintf,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerPrint
+	FN_ServerPrint,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Args
+	FN_Cmd_Args,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Argv
+	FN_Cmd_Argv,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Argc
+	FN_Cmd_Argc,
+#else
+	NULL,
+#endif
+#ifdef FN_GetAttachment
+	FN_GetAttachment,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_Init
+	FN_CRC32_Init,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_ProcessBuffer
+	FN_CRC32_ProcessBuffer,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_ProcessByte
+	FN_CRC32_ProcessByte,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_Final
+	FN_CRC32_Final,
+#else
+	NULL,
+#endif
+#ifdef FN_RandomLong
+	FN_RandomLong,
+#else
+	NULL,
+#endif
+#ifdef FN_RandomFloat
+	FN_RandomFloat,
+#else
+	NULL,
+#endif
+#ifdef FN_SetView
+	FN_SetView,
+#else
+	NULL,
+#endif
+#ifdef FN_Time
+	FN_Time,
+#else
+	NULL,
+#endif
+#ifdef FN_CrosshairAngle
+	FN_CrosshairAngle,
+#else
+	NULL,
+#endif
+#ifdef FN_LoadFileForMe
+	FN_LoadFileForMe,
+#else
+	NULL,
+#endif
+#ifdef FN_FreeFile
+	FN_FreeFile,
+#else
+	NULL,
+#endif
+#ifdef FN_EndSection
+	FN_EndSection,
+#else
+	NULL,
+#endif
+#ifdef FN_CompareFileTime
+	FN_CompareFileTime,
+#else
+	NULL,
+#endif
+#ifdef FN_GetGameDir
+	FN_GetGameDir,
+#else
+	NULL,
+#endif
+#ifdef FN_Cvar_RegisterVariable
+	FN_Cvar_RegisterVariable,
+#else
+	NULL,
+#endif
+#ifdef FN_FadeClientVolume
+	FN_FadeClientVolume,
+#else
+	NULL,
+#endif
+#ifdef FN_SetClientMaxspeed
+	FN_SetClientMaxspeed,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateFakeClient
+	FN_CreateFakeClient,
+#else
+	NULL,
+#endif
+#ifdef FN_RunPlayerMove
+	FN_RunPlayerMove,
+#else
+	NULL,
+#endif
+#ifdef FN_NumberOfEntities
+	FN_NumberOfEntities,
+#else
+	NULL,
+#endif
+#ifdef FN_GetInfoKeyBuffer
+	FN_GetInfoKeyBuffer,
+#else
+	NULL,
+#endif
+#ifdef FN_InfoKeyValue
+	FN_InfoKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_SetKeyValue
+	FN_SetKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_SetClientKeyValue
+	FN_SetClientKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_IsMapValid
+	FN_IsMapValid,
+#else
+	NULL,
+#endif
+#ifdef FN_StaticDecal
+	FN_StaticDecal,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheGeneric
+	FN_PrecacheGeneric,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerUserId
+	FN_GetPlayerUserId,
+#else
+	NULL,
+#endif
+#ifdef FN_BuildSoundMsg
+	FN_BuildSoundMsg,
+#else
+	NULL,
+#endif
+#ifdef FN_IsDedicatedServer
+	FN_IsDedicatedServer,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetPointer
+	FN_CVarGetPointer,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerWONId
+	FN_GetPlayerWONId,
+#else
+	NULL,
+#endif
+#ifdef FN_Info_RemoveKey
+	FN_Info_RemoveKey,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPhysicsKeyValue
+	FN_GetPhysicsKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_SetPhysicsKeyValue
+	FN_SetPhysicsKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPhysicsInfoString
+	FN_GetPhysicsInfoString,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheEvent
+	FN_PrecacheEvent,
+#else
+	NULL,
+#endif
+#ifdef FN_PlaybackEvent
+	FN_PlaybackEvent,
+#else
+	NULL,
+#endif
+#ifdef FN_SetFatPVS
+	FN_SetFatPVS,
+#else
+	NULL,
+#endif
+#ifdef FN_SetFatPAS
+	FN_SetFatPAS,
+#else
+	NULL,
+#endif
+#ifdef FN_CheckVisibility
+	FN_CheckVisibility,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaSetField
+	FN_DeltaSetField,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaUnsetField
+	FN_DeltaUnsetField,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaAddEncoder
+	FN_DeltaAddEncoder,
+#else
+	NULL,
+#endif
+#ifdef FN_GetCurrentPlayer
+	FN_GetCurrentPlayer,
+#else
+	NULL,
+#endif
+#ifdef FN_CanSkipPlayer
+	FN_CanSkipPlayer,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaFindField
+	FN_DeltaFindField,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaSetFieldByIndex
+	FN_DeltaSetFieldByIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaUnsetFieldByIndex
+	FN_DeltaUnsetFieldByIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_SetGroupMask
+	FN_SetGroupMask,
+#else
+	NULL,
+#endif
+#ifdef FN_engCreateInstancedBaseline
+	FN_engCreateInstancedBaseline,
+#else
+	NULL,
+#endif
+#ifdef FN_Cvar_DirectSet
+	FN_Cvar_DirectSet,
+#else
+	NULL,
+#endif
+#ifdef FN_ForceUnmodified
+	FN_ForceUnmodified,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerStats
+	FN_GetPlayerStats,
+#else
+	NULL,
+#endif
+#ifdef FN_AddServerCommand
+	FN_AddServerCommand,
+#else
+	NULL,
+#endif
+#ifdef FN_Voice_GetClientListening
+	FN_Voice_GetClientListening,
+#else
+	NULL,
+#endif
+#ifdef FN_Voice_SetClientListening
+	FN_Voice_SetClientListening,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerAuthId
+	FN_GetPlayerAuthId
+#else
+	NULL
+#endif
+}; // g_EngineFuncs_Table
+
+
+static enginefuncs_t g_EngineFuncs_Post_Table =
+{
+#ifdef FN_PrecacheModel_Post
+	FN_PrecacheModel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheSound_Post
+	FN_PrecacheSound_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetModel_Post
+	FN_SetModel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ModelIndex_Post
+	FN_ModelIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ModelFrames_Post
+	FN_ModelFrames_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetSize_Post
+	FN_SetSize_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangeLevel_Post
+	FN_ChangeLevel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetSpawnParms_Post
+	FN_GetSpawnParms_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveSpawnParms_Post
+	FN_SaveSpawnParms_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_VecToYaw_Post
+	FN_VecToYaw_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_VecToAngles_Post
+	FN_VecToAngles_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_MoveToOrigin_Post
+	FN_MoveToOrigin_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangeYaw_Post
+	FN_ChangeYaw_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangePitch_Post
+	FN_ChangePitch_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityByString_Post
+	FN_FindEntityByString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetEntityIllum_Post
+	FN_GetEntityIllum_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityInSphere_Post
+	FN_FindEntityInSphere_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FindClientInPVS_Post
+	FN_FindClientInPVS_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EntitiesInPVS_Post
+	FN_EntitiesInPVS_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_MakeVectors_Post
+	FN_MakeVectors_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AngleVectors_Post
+	FN_AngleVectors_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateEntity_Post
+	FN_CreateEntity_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RemoveEntity_Post
+	FN_RemoveEntity_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateNamedEntity_Post
+	FN_CreateNamedEntity_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_MakeStatic_Post
+	FN_MakeStatic_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EntIsOnFloor_Post
+	FN_EntIsOnFloor_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DropToFloor_Post
+	FN_DropToFloor_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WalkMove_Post
+	FN_WalkMove_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetOrigin_Post
+	FN_SetOrigin_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EmitSound_Post
+	FN_EmitSound_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EmitAmbientSound_Post
+	FN_EmitAmbientSound_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceLine_Post
+	FN_TraceLine_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceToss_Post
+	FN_TraceToss_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceMonsterHull_Post
+	FN_TraceMonsterHull_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceHull_Post
+	FN_TraceHull_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceModel_Post
+	FN_TraceModel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceTexture_Post
+	FN_TraceTexture_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceSphere_Post
+	FN_TraceSphere_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetAimVector_Post
+	FN_GetAimVector_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerCommand_Post
+	FN_ServerCommand_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerExecute_Post
+	FN_ServerExecute_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_engClientCommand_Post
+	FN_engClientCommand_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ParticleEffect_Post
+	FN_ParticleEffect_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_LightStyle_Post
+	FN_LightStyle_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DecalIndex_Post
+	FN_DecalIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PointContents_Post
+	FN_PointContents_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_MessageBegin_Post
+	FN_MessageBegin_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_MessageEnd_Post
+	FN_MessageEnd_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteByte_Post
+	FN_WriteByte_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteChar_Post
+	FN_WriteChar_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteShort_Post
+	FN_WriteShort_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteLong_Post
+	FN_WriteLong_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteAngle_Post
+	FN_WriteAngle_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteCoord_Post
+	FN_WriteCoord_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteString_Post
+	FN_WriteString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteEntity_Post
+	FN_WriteEntity_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarRegister_Post
+	FN_CVarRegister_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetFloat_Post
+	FN_CVarGetFloat_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetString_Post
+	FN_CVarGetString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarSetFloat_Post
+	FN_CVarSetFloat_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarSetString_Post
+	FN_CVarSetString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AlertMessage_Post
+	FN_AlertMessage_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EngineFprintf_Post
+	FN_EngineFprintf_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PvAllocEntPrivateData_Post
+	FN_PvAllocEntPrivateData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PvEntPrivateData_Post
+	FN_PvEntPrivateData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FreeEntPrivateData_Post
+	FN_FreeEntPrivateData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SzFromIndex_Post
+	FN_SzFromIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AllocString_Post
+	FN_AllocString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetVarsOfEnt_Post
+	FN_GetVarsOfEnt_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PEntityOfEntOffset_Post
+	FN_PEntityOfEntOffset_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EntOffsetOfPEntity_Post
+	FN_EntOffsetOfPEntity_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_IndexOfEdict_Post
+	FN_IndexOfEdict_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PEntityOfEntIndex_Post
+	FN_PEntityOfEntIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityByVars_Post
+	FN_FindEntityByVars_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetModelPtr_Post
+	FN_GetModelPtr_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RegUserMsg_Post
+	FN_RegUserMsg_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AnimationAutomove_Post
+	FN_AnimationAutomove_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetBonePosition_Post
+	FN_GetBonePosition_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FunctionFromName_Post
+	FN_FunctionFromName_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_NameForFunction_Post
+	FN_NameForFunction_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientPrintf_Post
+	FN_ClientPrintf_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerPrint_Post
+	FN_ServerPrint_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Args_Post
+	FN_Cmd_Args_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Argv_Post
+	FN_Cmd_Argv_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Argc_Post
+	FN_Cmd_Argc_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetAttachment_Post
+	FN_GetAttachment_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_Init_Post
+	FN_CRC32_Init_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_ProcessBuffer_Post
+	FN_CRC32_ProcessBuffer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_ProcessByte_Post
+	FN_CRC32_ProcessByte_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_Final_Post
+	FN_CRC32_Final_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RandomLong_Post
+	FN_RandomLong_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RandomFloat_Post
+	FN_RandomFloat_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetView_Post
+	FN_SetView_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Time_Post
+	FN_Time_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CrosshairAngle_Post
+	FN_CrosshairAngle_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_LoadFileForMe_Post
+	FN_LoadFileForMe_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FreeFile_Post
+	FN_FreeFile_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EndSection_Post
+	FN_EndSection_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CompareFileTime_Post
+	FN_CompareFileTime_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetGameDir_Post
+	FN_GetGameDir_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Cvar_RegisterVariable_Post
+	FN_Cvar_RegisterVariable_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FadeClientVolume_Post
+	FN_FadeClientVolume_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetClientMaxspeed_Post
+	FN_SetClientMaxspeed_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateFakeClient_Post
+	FN_CreateFakeClient_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RunPlayerMove_Post
+	FN_RunPlayerMove_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_NumberOfEntities_Post
+	FN_NumberOfEntities_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetInfoKeyBuffer_Post
+	FN_GetInfoKeyBuffer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_InfoKeyValue_Post
+	FN_InfoKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetKeyValue_Post
+	FN_SetKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetClientKeyValue_Post
+	FN_SetClientKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_IsMapValid_Post
+	FN_IsMapValid_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_StaticDecal_Post
+	FN_StaticDecal_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheGeneric_Post
+	FN_PrecacheGeneric_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerUserId_Post
+	FN_GetPlayerUserId_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_BuildSoundMsg_Post
+	FN_BuildSoundMsg_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_IsDedicatedServer_Post
+	FN_IsDedicatedServer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetPointer_Post
+	FN_CVarGetPointer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerWONId_Post
+	FN_GetPlayerWONId_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Info_RemoveKey_Post
+	FN_Info_RemoveKey_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPhysicsKeyValue_Post
+	FN_GetPhysicsKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetPhysicsKeyValue_Post
+	FN_SetPhysicsKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPhysicsInfoString_Post
+	FN_GetPhysicsInfoString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheEvent_Post
+	FN_PrecacheEvent_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PlaybackEvent_Post
+	FN_PlaybackEvent_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetFatPVS_Post
+	FN_SetFatPVS_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetFatPAS_Post
+	FN_SetFatPAS_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CheckVisibility_Post
+	FN_CheckVisibility_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaSetField_Post
+	FN_DeltaSetField_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaUnsetField_Post
+	FN_DeltaUnsetField_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaAddEncoder_Post
+	FN_DeltaAddEncoder_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetCurrentPlayer_Post
+	FN_GetCurrentPlayer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CanSkipPlayer_Post
+	FN_CanSkipPlayer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaFindField_Post
+	FN_DeltaFindField_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaSetFieldByIndex_Post
+	FN_DeltaSetFieldByIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaUnsetFieldByIndex_Post
+	FN_DeltaUnsetFieldByIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetGroupMask_Post
+	FN_SetGroupMask_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_engCreateInstancedBaseline_Post
+	FN_engCreateInstancedBaseline_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Cvar_DirectSet_Post
+	FN_Cvar_DirectSet_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ForceUnmodified_Post
+	FN_ForceUnmodified_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerStats_Post
+	FN_GetPlayerStats_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AddServerCommand_Post
+	FN_AddServerCommand_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Voice_GetClientListening_Post
+	FN_Voice_GetClientListening_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Voice_SetClientListening_Post
+	FN_Voice_SetClientListening_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerAuthId_Post
+	FN_GetPlayerAuthId_Post
+#else
+	NULL
+#endif
+}; // g_EngineFuncs_Post_Table
+
+
+static NEW_DLL_FUNCTIONS g_NewFuncs_Table = 
+{
+#ifdef FN_OnFreeEntPrivateData
+	FN_OnFreeEntPrivateData,
+#else
+	NULL,
+#endif
+#ifdef FN_GameShutdown
+	FN_GameShutdown,
+#else
+	NULL,
+#endif
+#ifdef FN_ShouldCollide
+	ShouldCollide,
+#else
+	NULL,
+#endif
+};
+
+
+static NEW_DLL_FUNCTIONS g_NewFuncs_Post_Table = 
+{
+#ifdef FN_OnFreeEntPrivateData_Post
+	FN_OnFreeEntPrivateData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GameShutdown_Post
+	FN_GameShutdown_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ShouldCollide_Post
+	ShouldCollide_Post,
+#else
+	NULL,
+#endif
+};
+
+// Global variables from metamod.  These variable names are referenced by
+// various macros.
+meta_globals_t *gpMetaGlobals;		// metamod globals
+gamedll_funcs_t *gpGamedllFuncs;	// gameDLL function tables
+mutil_funcs_t *gpMetaUtilFuncs;		// metamod utility functions
+
+
+plugin_info_t Plugin_info = {
+		META_INTERFACE_VERSION,
+		MODULE_NAME,
+		MODULE_VERSION,
+		MODULE_DATE,
+		MODULE_AUTHOR,
+		MODULE_URL,
+		MODULE_LOGTAG,
+		PT_ANYTIME,
+		PT_ANYTIME
+};
+
+/*
+C_DLLEXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEntityAPI; version=%d", interfaceVersion);
+	if(!pFunctionTable) {
+		LOG_ERROR(PLID, "GetEntityAPI called with null pFunctionTable");
+		return(FALSE);
+	}
+	else if(interfaceVersion != INTERFACE_VERSION) {
+		LOG_ERROR(PLID, "GetEntityAPI version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION);
+		return(FALSE);
+	}
+	memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof( DLL_FUNCTIONS ) );
+
+	return (TRUE);
+}
+
+C_DLLEXPORT int GetEntityAPI_Post(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEntityAPI_Post; version=%d", interfaceVersion);
+	if(!pFunctionTable) {
+		LOG_ERROR(PLID, "GetEntityAPI_Post called with null pFunctionTable");
+		return(FALSE);
+	}
+	else if(interfaceVersion != INTERFACE_VERSION) {
+		LOG_ERROR(PLID, "GetEntityAPI_Post version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION);
+		return(FALSE);
+	}
+	memcpy(pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) );
+
+	return(TRUE);
+}
+*/
+
+C_DLLEXPORT int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEntityAPI2; version=%d", *interfaceVersion);
+	if(!pFunctionTable) {
+		LOG_ERROR(PLID, "GetEntityAPI2 called with null pFunctionTable");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != INTERFACE_VERSION) {
+		LOG_ERROR(PLID, 
+				"GetEntityAPI2 version mismatch; requested=%d ours=%d", 
+				*interfaceVersion, INTERFACE_VERSION);
+		//! Tell engine what version we had, so it can figure out who is 
+		//! out of date.
+		*interfaceVersion = INTERFACE_VERSION;
+		return(FALSE);
+	}
+	memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof(DLL_FUNCTIONS));
+	g_pFunctionTable=pFunctionTable;
+	return(TRUE);
+}
+
+C_DLLEXPORT int GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEntityAPI2_Post; version=%d", *interfaceVersion);
+	if(!pFunctionTable) {
+		LOG_ERROR(PLID, "GetEntityAPI2_Post called with null pFunctionTable");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != INTERFACE_VERSION) {
+		LOG_ERROR(PLID, "GetEntityAPI2_Post version mismatch; requested=%d ours=%d", *interfaceVersion, INTERFACE_VERSION);
+		//! Tell engine what version we had, so it can figure out who is out of date.
+		*interfaceVersion = INTERFACE_VERSION;
+		return(FALSE);
+	}
+	memcpy( pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) );
+	g_pFunctionTable_Post=pFunctionTable;
+	return(TRUE);
+}
+
+C_DLLEXPORT int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEngineFunctions; version=%d", 
+			*interfaceVersion);
+	if(!pengfuncsFromEngine) {
+		LOG_ERROR(PLID, 
+				"GetEngineFunctions called with null pengfuncsFromEngine");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) {
+		LOG_ERROR(PLID, 
+				"GetEngineFunctions version mismatch; requested=%d ours=%d", 
+				*interfaceVersion, ENGINE_INTERFACE_VERSION);
+		// Tell metamod what version we had, so it can figure out who is 
+		// out of date.
+		*interfaceVersion = ENGINE_INTERFACE_VERSION;
+		return(FALSE);
+	}
+	memcpy(pengfuncsFromEngine, &g_EngineFuncs_Table, sizeof(enginefuncs_t));
+	g_pengfuncsTable=pengfuncsFromEngine;
+	return TRUE;
+}
+
+C_DLLEXPORT int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEngineFunctions_Post; version=%d", *interfaceVersion);
+	if(!pengfuncsFromEngine) {
+		LOG_ERROR(PLID, "GetEngineFunctions_Post called with null pengfuncsFromEngine");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) {
+		LOG_ERROR(PLID, "GetEngineFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, ENGINE_INTERFACE_VERSION);
+		// Tell metamod what version we had, so it can figure out who is out of date.
+		*interfaceVersion = ENGINE_INTERFACE_VERSION;
+		return(FALSE);
+	}
+	memcpy(pengfuncsFromEngine, &g_EngineFuncs_Post_Table, sizeof(enginefuncs_t));
+	g_pengfuncsTable_Post=pengfuncsFromEngine;
+	return TRUE;
+
+}
+
+C_DLLEXPORT int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pNewFunctionTable, 
+		int *interfaceVersion) 
+{
+	LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions; version=%d", 
+			*interfaceVersion);
+	if(!pNewFunctionTable) {
+		LOG_ERROR(PLID, 
+				"GetNewDLLFunctions called with null pNewFunctionTable");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) {
+		LOG_ERROR(PLID, 
+				"GetNewDLLFunctions version mismatch; requested=%d ours=%d", 
+				*interfaceVersion, NEW_DLL_FUNCTIONS_VERSION);
+		//! Tell engine what version we had, so it can figure out who is 
+		//! out of date.
+		*interfaceVersion = NEW_DLL_FUNCTIONS_VERSION;
+		return(FALSE);
+	}
+	memcpy(pNewFunctionTable, &g_NewFuncs_Table, sizeof(NEW_DLL_FUNCTIONS));
+	g_pNewFunctionsTable=pNewFunctionTable;
+	return TRUE;
+}
+
+C_DLLEXPORT int GetNewDLLFunctions_Post( NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion ) 
+{
+	LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions_Post; version=%d", *interfaceVersion);
+	if(!pNewFunctionTable) {
+		LOG_ERROR(PLID, "GetNewDLLFunctions_Post called with null pNewFunctionTable");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) {
+		LOG_ERROR(PLID, "GetNewDLLFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, NEW_DLL_FUNCTIONS_VERSION);
+		//! Tell engine what version we had, so it can figure out who is out of date.
+		*interfaceVersion = NEW_DLL_FUNCTIONS_VERSION;
+		return(FALSE);
+	}
+	memcpy(pNewFunctionTable, &g_NewFuncs_Post_Table, sizeof(NEW_DLL_FUNCTIONS));
+	g_pNewFunctionsTable_Post=pNewFunctionTable;
+	return TRUE;
+}
+
+
+static META_FUNCTIONS g_MetaFunctions_Table =
+{
+	NULL,
+	NULL,
+	GetEntityAPI2,
+	GetEntityAPI2_Post,
+	GetNewDLLFunctions,
+	GetNewDLLFunctions_Post,
+	GetEngineFunctions,
+	GetEngineFunctions_Post
+};
+
+C_DLLEXPORT int Meta_Query(char *ifvers, plugin_info_t **pPlugInfo, mutil_funcs_t *pMetaUtilFuncs)
+{
+	if ((int) CVAR_GET_FLOAT("developer") != 0)
+		UTIL_LogPrintf("[%s] dev: called: Meta_Query; version=%s, ours=%s\n", 
+				Plugin_info.logtag, ifvers, Plugin_info.ifvers);
+
+	// Check for valid pMetaUtilFuncs before we continue.
+	if(!pMetaUtilFuncs) {
+		UTIL_LogPrintf("[%s] ERROR: Meta_Query called with null pMetaUtilFuncs\n", Plugin_info.logtag);
+		return(FALSE);
+	}
+
+	gpMetaUtilFuncs = pMetaUtilFuncs;
+
+	*pPlugInfo = &Plugin_info;
+
+	// Check for interface version compatibility.
+	if(!FStrEq(ifvers, Plugin_info.ifvers)) {
+		int mmajor=0, mminor=0, pmajor=0, pminor=0;
+		LOG_MESSAGE(PLID, "WARNING: meta-interface version mismatch; requested=%s ours=%s",
+				Plugin_info.logtag, ifvers);
+		// If plugin has later interface version, it's incompatible (update
+		// metamod).
+		sscanf(ifvers, "%d:%d", &mmajor, &mminor);
+		sscanf(META_INTERFACE_VERSION, "%d:%d", &pmajor, &pminor);
+		if(pmajor > mmajor || (pmajor==mmajor && pminor > mminor)) {
+			LOG_ERROR(PLID, "metamod version is too old for this module; update metamod");
+			return(FALSE);
+		}
+		// If plugin has older major interface version, it's incompatible
+		// (update plugin).
+		else if(pmajor < mmajor) {
+			LOG_ERROR(PLID, "metamod version is incompatible with this module; please find a newer version of this module");
+			return(FALSE);
+		}
+		// Minor interface is older, but this is guaranteed to be backwards
+		// compatible, so we warn, but we still accept it.
+		else if(pmajor==mmajor && pminor < mminor)
+			LOG_MESSAGE(PLID, "WARNING: metamod version is newer than expected; consider finding a newer version of this module");
+		else
+			LOG_ERROR(PLID, "unexpected version comparison; metavers=%s, mmajor=%d, mminor=%d; plugvers=%s, pmajor=%d, pminor=%d", ifvers, mmajor, mminor, META_INTERFACE_VERSION, pmajor, pminor);
+	}
+
+#ifdef FN_META_QUERY
+	return FN_META_QUERY();
+#endif	// FN_META_QUERY
+
+	return 1;
+}
+
+
+C_DLLEXPORT int Meta_Attach(PLUG_LOADTIME now, META_FUNCTIONS *pFunctionTable, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs)
+{
+	if(now > Plugin_info.loadable) {
+		LOG_ERROR(PLID, "Can't load module right now");
+		return(FALSE);
+	}
+	if(!pMGlobals) {
+		LOG_ERROR(PLID, "Meta_Attach called with null pMGlobals");
+		return(FALSE);
+	}
+	gpMetaGlobals=pMGlobals;
+	if(!pFunctionTable) {
+		LOG_ERROR(PLID, "Meta_Attach called with null pFunctionTable");
+		return(FALSE);
+	}
+
+	memcpy(pFunctionTable, &g_MetaFunctions_Table, sizeof(META_FUNCTIONS));
+	gpGamedllFuncs=pGamedllFuncs;
+
+	// Let's go.
+
+#ifdef FN_META_ATTACH
+	FN_META_ATTACH();
+#endif	// FN_META_ATTACH
+
+	return TRUE;
+}
+
+C_DLLEXPORT int Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason)
+{
+	if(now > Plugin_info.unloadable && reason != PNL_CMD_FORCED) {
+		LOG_ERROR(PLID, "Can't unload plugin right now");
+		return(FALSE);
+	}
+
+#ifdef FN_META_DETACH
+	return FN_META_DETACH();
+#endif	// FN_META_DETACH
+	return TRUE;
+}
+
+
+
+#ifdef __linux__
+// linux prototype
+C_DLLEXPORT void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) {
+
+#else
+#ifdef _MSC_VER
+// MSVC: Simulate __stdcall calling convention
+C_DLLEXPORT __declspec(naked) void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
+{
+	__asm			// Prolog
+	{
+		// Save ebp
+		push		ebp
+		// Set stack frame pointer
+		mov			ebp, esp
+		// Allocate space for local variables
+		// The MSVC compiler gives us the needed size in __LOCAL_SIZE.
+		sub			esp, __LOCAL_SIZE
+		// Push registers
+		push		ebx
+		push		esi
+		push		edi
+	}
+#else	// _MSC_VER
+#ifdef __GNUC__
+// GCC can also work with this
+C_DLLEXPORT void __stdcall GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
+{
+#else	// __GNUC__
+// compiler not known
+#error There is no support (yet) for your compiler. Please use MSVC or GCC compilers or contact the AMX Mod X dev team.
+#endif	// __GNUC__
+#endif // _MSC_VER
+#endif // __linux__
+
+	// ** Function core <--
+	memcpy(&g_engfuncs, pengfuncsFromEngine, sizeof(enginefuncs_t));
+	gpGlobals = pGlobals;
+	// NOTE!  Have to call logging function _after_ copying into g_engfuncs, so
+	// that g_engfuncs.pfnAlertMessage() can be resolved properly, heh. :)
+	UTIL_LogPrintf("[%s] dev: called: GiveFnptrsToDll\n", Plugin_info.logtag);
+	// --> ** Function core
+
+#ifdef _MSC_VER
+	// Epilog
+	if (sizeof(int*) == 8)
+	{	// 64 bit
+		__asm
+		{
+			// Pop registers
+			pop	edi
+			pop	esi
+			pop	ebx
+			// Restore stack frame pointer
+			mov	esp, ebp
+			// Restore ebp
+			pop	ebp
+			// 2 * sizeof(int*) = 16 on 64 bit
+			ret 16
+		}
+	}
+	else
+	{	// 32 bit
+		__asm
+		{
+			// Pop registers
+			pop	edi
+			pop	esi
+			pop	ebx
+			// Restore stack frame pointer
+			mov	esp, ebp
+			// Restore ebp
+			pop	ebp
+			// 2 * sizeof(int*) = 8 on 32 bit
+			ret 8
+		}
+	}
+#endif // #ifdef _MSC_VER
+}
+
+#endif	// #ifdef USE_METAMOD
+
+/************* AMXX Stuff *************/
+
+// *** Types ***
+typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/);
+
+// *** Globals ***
+// Module info
+static amxx_module_info_s g_ModuleInfo = 
+{
+	MODULE_NAME,
+	MODULE_AUTHOR,
+	MODULE_VERSION,
+#ifdef MODULE_RELOAD_ON_MAPCHANGE
+	1
+#else // MODULE_RELOAD_ON_MAPCHANGE
+	0
+#endif // MODULE_RELOAD_ON_MAPCHANGE
+};
+
+// Storage for the requested functions
+PFN_ADD_NATIVES				g_fn_AddNatives;
+PFN_BUILD_PATHNAME			g_fn_BuildPathname;
+PFN_GET_AMXADDR				g_fn_GetAmxAddr;
+PFN_PRINT_SRVCONSOLE		g_fn_PrintSrvConsole;
+PFN_GET_MODNAME				g_fn_GetModname;
+PFN_GET_AMXSCRIPTNAME		g_fn_GetAmxScriptName;
+PFN_GET_AMXSCRIPT			g_fn_GetAmxScript;
+PFN_FIND_AMXSCRIPT_BYAMX	g_fn_FindAmxScriptByAmx;
+PFN_FIND_AMXSCRIPT_BYNAME	g_fn_FindAmxScriptByName;
+PFN_SET_AMXSTRING			g_fn_SetAmxString;
+PFN_GET_AMXSTRING			g_fn_GetAmxString;
+PFN_GET_AMXSTRINGLEN		g_fn_GetAmxStringLen;
+PFN_FORMAT_AMXSTRING		g_fn_FormatAmxString;
+PFN_COPY_AMXMEMORY			g_fn_CopyAmxMemory;
+PFN_LOG						g_fn_Log;
+PFN_LOG_ERROR				g_fn_LogErrorFunc;
+PFN_RAISE_AMXERROR			g_fn_RaiseAmxError;
+PFN_REGISTER_FORWARD		g_fn_RegisterForward;
+PFN_EXECUTE_FORWARD			g_fn_ExecuteForward;
+PFN_PREPARE_CELLARRAY		g_fn_PrepareCellArray;
+PFN_PREPARE_CHARARRAY		g_fn_PrepareCharArray;
+PFN_PREPARE_CELLARRAY_A		g_fn_PrepareCellArrayA;
+PFN_PREPARE_CHARARRAY_A		g_fn_PrepareCharArrayA;
+PFN_IS_PLAYER_VALID			g_fn_IsPlayerValid;
+PFN_GET_PLAYER_NAME			g_fn_GetPlayerName;
+PFN_GET_PLAYER_IP			g_fn_GetPlayerIP;
+PFN_IS_PLAYER_INGAME		g_fn_IsPlayerIngame;
+PFN_IS_PLAYER_BOT			g_fn_IsPlayerBot;
+PFN_IS_PLAYER_AUTHORIZED	g_fn_IsPlayerAuthorized;
+PFN_GET_PLAYER_TIME			g_fn_GetPlayerTime;
+PFN_GET_PLAYER_PLAYTIME		g_fn_GetPlayerPlayTime;
+PFN_GET_PLAYER_CURWEAPON	g_fn_GetPlayerCurweapon;
+PFN_GET_PLAYER_TEAM			g_fn_GetPlayerTeam;
+PFN_GET_PLAYER_TEAMID		g_fn_GetPlayerTeamID;
+PFN_GET_PLAYER_DEATHS		g_fn_GetPlayerDeaths;
+PFN_GET_PLAYER_MENU			g_fn_GetPlayerMenu;
+PFN_GET_PLAYER_KEYS			g_fn_GetPlayerKeys;
+PFN_IS_PLAYER_ALIVE			g_fn_IsPlayerAlive;
+PFN_GET_PLAYER_FRAGS		g_fn_GetPlayerFrags;
+PFN_IS_PLAYER_CONNECTING	g_fn_IsPlayerConnecting;
+PFN_IS_PLAYER_HLTV			g_fn_IsPlayerHLTV;
+PFN_GET_PLAYER_ARMOR		g_fn_GetPlayerArmor;
+PFN_GET_PLAYER_HEALTH		g_fn_GetPlayerHealth;
+PFN_ALLOCATOR				g_fn_Allocator;
+PFN_REALLOCATOR				g_fn_Reallocator;
+PFN_DEALLOCATOR				g_fn_Deallocator;
+PFN_AMX_EXEC				g_fn_AmxExec;
+PFN_AMX_EXECV				g_fn_AmxExecv;
+PFN_AMX_ALLOT				g_fn_AmxAllot;
+PFN_AMX_FINDPUBLIC			g_fn_AmxFindPublic;
+PFN_LOAD_AMXSCRIPT			g_fn_LoadAmxScript;
+PFN_UNLOAD_AMXSCRIPT		g_fn_UnloadAmxScript;
+PFN_REAL_TO_CELL			g_fn_RealToCell;
+PFN_CELL_TO_REAL			g_fn_CellToReal;
+PFN_REGISTER_SPFORWARD		g_fn_RegisterSPForward;
+PFN_REGISTER_SPFORWARD_BYNAME	g_fn_RegisterSPForwardByName;
+PFN_UNREGISTER_SPFORWARD	g_fn_UnregisterSPForward;
+PFN_MERGEDEFINITION_FILE	g_fn_MergeDefinition_File;
+PFN_AMX_FINDNATIVE			g_fn_AmxFindNative;
+PFN_GETPLAYERFLAGS			g_fn_GetPlayerFlags;
+PFN_GET_PLAYER_EDICT		g_fn_GetPlayerEdict;
+PFN_FORMAT					g_fn_Format;
+
+// *** Exports ***
+C_DLLEXPORT int AMXX_Query(int *interfaceVersion, amxx_module_info_s *moduleInfo)
+{
+	// check parameters
+	if (!interfaceVersion || !moduleInfo)
+		return AMXX_PARAM;
+
+	// check interface version
+	if (*interfaceVersion != AMXX_INTERFACE_VERSION)
+	{
+		// Tell amxx core our interface version
+		*interfaceVersion = AMXX_INTERFACE_VERSION;
+		return AMXX_IFVERS;
+	}
+
+	// copy module info
+	memcpy(moduleInfo, &g_ModuleInfo, sizeof(amxx_module_info_s));
+
+#ifdef FN_AMXX_QUERY
+	FN_AMXX_QUERY();
+#endif // FN_AMXX_QUERY
+	// Everything ok :)
+	return AMXX_OK;
+}
+
+// request function
+#define REQFUNC(name, fptr, type) if ((fptr = (type)reqFnptrFunc(name)) == 0) return AMXX_FUNC_NOT_PRESENT
+// request optional function
+#define REQFUNC_OPT(name, fptr, type) fptr = (type)reqFnptrFunc(name)
+
+C_DLLEXPORT int AMXX_Attach(PFN_REQ_FNPTR reqFnptrFunc)
+{
+	// Check pointer
+	if (!reqFnptrFunc)
+		return AMXX_PARAM;
+
+	// Req all known functions
+	// Misc
+	REQFUNC("BuildPathname", g_fn_BuildPathname, PFN_BUILD_PATHNAME);
+	REQFUNC("PrintSrvConsole", g_fn_PrintSrvConsole, PFN_PRINT_SRVCONSOLE);
+	REQFUNC("GetModname", g_fn_GetModname, PFN_GET_MODNAME);
+	REQFUNC("Log", g_fn_Log, PFN_LOG);
+	REQFUNC("LogError", g_fn_LogErrorFunc, PFN_LOG_ERROR);
+	REQFUNC("MergeDefinitionFile", g_fn_MergeDefinition_File, PFN_MERGEDEFINITION_FILE);
+	REQFUNC("Format", g_fn_Format, PFN_FORMAT);
+
+	// Amx scripts
+	REQFUNC("GetAmxScript", g_fn_GetAmxScript, PFN_GET_AMXSCRIPT);
+	REQFUNC("FindAmxScriptByAmx", g_fn_FindAmxScriptByAmx, PFN_FIND_AMXSCRIPT_BYAMX);
+	REQFUNC("FindAmxScriptByName", g_fn_FindAmxScriptByName, PFN_FIND_AMXSCRIPT_BYNAME);
+	REQFUNC("LoadAmxScript", g_fn_LoadAmxScript, PFN_LOAD_AMXSCRIPT);
+	REQFUNC("UnloadAmxScript", g_fn_UnloadAmxScript, PFN_UNLOAD_AMXSCRIPT);
+    REQFUNC("GetAmxScriptName", g_fn_GetAmxScriptName, PFN_GET_AMXSCRIPTNAME);
+
+	// String / mem in amx scripts support
+	REQFUNC("SetAmxString", g_fn_SetAmxString, PFN_SET_AMXSTRING);
+	REQFUNC("GetAmxString", g_fn_GetAmxString, PFN_GET_AMXSTRING);
+	REQFUNC("GetAmxStringLen", g_fn_GetAmxStringLen, PFN_GET_AMXSTRINGLEN);
+	REQFUNC("FormatAmxString", g_fn_FormatAmxString, PFN_FORMAT_AMXSTRING);
+	REQFUNC("CopyAmxMemory", g_fn_CopyAmxMemory, PFN_COPY_AMXMEMORY);
+	REQFUNC("GetAmxAddr", g_fn_GetAmxAddr, PFN_GET_AMXADDR);
+
+	REQFUNC("amx_Exec", g_fn_AmxExec, PFN_AMX_EXEC);
+	REQFUNC("amx_Execv", g_fn_AmxExecv, PFN_AMX_EXECV);
+	REQFUNC("amx_FindPublic", g_fn_AmxFindPublic, PFN_AMX_FINDPUBLIC);
+	REQFUNC("amx_Allot", g_fn_AmxAllot, PFN_AMX_ALLOT);
+	REQFUNC("amx_FindNative", g_fn_AmxFindNative, PFN_AMX_FINDNATIVE);
+
+	// Natives / Forwards
+	REQFUNC("AddNatives", g_fn_AddNatives, PFN_ADD_NATIVES);
+	REQFUNC("RaiseAmxError", g_fn_RaiseAmxError, PFN_RAISE_AMXERROR);
+	REQFUNC("RegisterForward", g_fn_RegisterForward, PFN_REGISTER_FORWARD);
+	REQFUNC("RegisterSPForward", g_fn_RegisterSPForward, PFN_REGISTER_SPFORWARD);
+	REQFUNC("RegisterSPForwardByName", g_fn_RegisterSPForwardByName, PFN_REGISTER_SPFORWARD_BYNAME);
+	REQFUNC("UnregisterSPForward", g_fn_UnregisterSPForward, PFN_UNREGISTER_SPFORWARD);
+	REQFUNC("ExecuteForward", g_fn_ExecuteForward, PFN_EXECUTE_FORWARD);
+	REQFUNC("PrepareCellArray", g_fn_PrepareCellArray, PFN_PREPARE_CELLARRAY);
+	REQFUNC("PrepareCharArray", g_fn_PrepareCharArray, PFN_PREPARE_CHARARRAY);
+	REQFUNC("PrepareCellArrayA", g_fn_PrepareCellArrayA, PFN_PREPARE_CELLARRAY_A);
+	REQFUNC("PrepareCharArrayA", g_fn_PrepareCharArrayA, PFN_PREPARE_CHARARRAY_A);
+	// Player
+	REQFUNC("IsPlayerValid", g_fn_IsPlayerValid, PFN_IS_PLAYER_VALID);
+	REQFUNC("GetPlayerName", g_fn_GetPlayerName, PFN_GET_PLAYER_NAME);
+	REQFUNC("GetPlayerIP", g_fn_GetPlayerIP, PFN_GET_PLAYER_IP);
+	REQFUNC("IsPlayerInGame", g_fn_IsPlayerIngame, PFN_IS_PLAYER_INGAME);		
+	REQFUNC("IsPlayerBot", g_fn_IsPlayerBot, PFN_IS_PLAYER_BOT);	
+	REQFUNC("IsPlayerAuthorized", g_fn_IsPlayerAuthorized, PFN_IS_PLAYER_AUTHORIZED);
+	REQFUNC("GetPlayerTime", g_fn_GetPlayerTime, PFN_GET_PLAYER_TIME);
+	REQFUNC("GetPlayerPlayTime", g_fn_GetPlayerPlayTime, PFN_GET_PLAYER_PLAYTIME);
+	REQFUNC("GetPlayerCurweapon", g_fn_GetPlayerCurweapon, PFN_GET_PLAYER_CURWEAPON);
+	REQFUNC("GetPlayerTeamID", g_fn_GetPlayerTeamID, PFN_GET_PLAYER_TEAMID);
+	REQFUNC("GetPlayerTeam",g_fn_GetPlayerTeam, PFN_GET_PLAYER_TEAM);
+	REQFUNC("GetPlayerDeaths", g_fn_GetPlayerDeaths, PFN_GET_PLAYER_DEATHS);
+	REQFUNC("GetPlayerMenu", g_fn_GetPlayerMenu, PFN_GET_PLAYER_MENU);
+	REQFUNC("GetPlayerKeys", g_fn_GetPlayerKeys, PFN_GET_PLAYER_KEYS);
+	REQFUNC("IsPlayerAlive", g_fn_IsPlayerAlive, PFN_IS_PLAYER_ALIVE);
+	REQFUNC("GetPlayerFrags", g_fn_GetPlayerFrags, PFN_GET_PLAYER_FRAGS);
+	REQFUNC("IsPlayerConnecting", g_fn_IsPlayerConnecting, PFN_IS_PLAYER_CONNECTING);
+	REQFUNC("IsPlayerHLTV", g_fn_IsPlayerHLTV, PFN_IS_PLAYER_HLTV);
+	REQFUNC("GetPlayerArmor", g_fn_GetPlayerArmor, PFN_GET_PLAYER_ARMOR);
+	REQFUNC("GetPlayerHealth", g_fn_GetPlayerHealth, PFN_GET_PLAYER_HEALTH);
+	REQFUNC("GetPlayerFlags", g_fn_GetPlayerFlags, PFN_GETPLAYERFLAGS);
+	REQFUNC("GetPlayerEdict", g_fn_GetPlayerEdict, PFN_GET_PLAYER_EDICT);
+
+	// Memory
+	REQFUNC_OPT("Allocator", g_fn_Allocator, PFN_ALLOCATOR);
+	REQFUNC_OPT("Reallocator", g_fn_Reallocator, PFN_REALLOCATOR);
+	REQFUNC_OPT("Deallocator", g_fn_Deallocator, PFN_DEALLOCATOR);
+
+	REQFUNC("CellToReal", g_fn_CellToReal, PFN_CELL_TO_REAL);
+	REQFUNC("RealToCell", g_fn_RealToCell, PFN_REAL_TO_CELL);
+
+#ifdef FN_AMXX_ATTACH
+	FN_AMXX_ATTACH();
+#endif // FN_AMXX_ATACH
+
+	return AMXX_OK;
+}
+
+C_DLLEXPORT int AMXX_Detach()
+{
+#ifdef FN_AMXX_DETACH
+	FN_AMXX_DETACH();
+#endif // FN_AMXX_DETACH
+
+	return AMXX_OK;
+}
+
+C_DLLEXPORT int AMXX_PluginsLoaded()
+{
+#ifdef FN_AMXX_PLUGINSLOADED
+	FN_AMXX_PLUGINSLOADED();
+#endif // FN_AMXX_PLUGINSLOADED
+	return AMXX_OK;
+}
+
+// Advanced MF functions
+void MF_Log(const char *fmt, ...)
+{
+	// :TODO: Overflow possible here
+	char msg[3072];
+	va_list arglst;
+	va_start(arglst, fmt);
+	vsprintf(msg, fmt, arglst);
+	va_end(arglst);
+
+	g_fn_Log("[%s] %s", MODULE_NAME, msg);
+}
+
+void MF_LogError(AMX *amx, int err, const char *fmt, ...)
+{
+	// :TODO: Overflow possible here
+	char msg[3072];
+	va_list arglst;
+	va_start(arglst, fmt);
+	vsprintf(msg, fmt, arglst);
+	va_end(arglst);
+
+	g_fn_LogErrorFunc(amx, err, "[%s] %s", MODULE_NAME, msg);
+}
+
+
+#ifdef _DEBUG
+// validate macros
+// Makes sure compiler reports errors when macros are invalid
+void ValidateMacros_DontCallThis_Smiley()
+{
+	MF_BuildPathname("str", "str", 0);
+	MF_FormatAmxString(NULL, 0, 0, NULL);
+	MF_GetAmxAddr(NULL, 0);
+	MF_PrintSrvConsole("str", "str", 0);
+	MF_GetModname();
+	MF_GetScriptName(0);
+	MF_GetScriptAmx(0);
+	MF_FindScriptByAmx(NULL);
+	MF_FindScriptByName("str");
+	MF_SetAmxString(NULL, 0, "str", 0);
+	MF_GetAmxString(NULL, 0, 0, 0);
+	MF_GetAmxStringLen(NULL);
+	MF_CopyAmxMemory(NULL, NULL, 0);
+	MF_Log("str", "str", 0);
+	MF_LogError(NULL, 0, NULL);
+	MF_RaiseAmxError(NULL, 0);
+	MF_RegisterForward("str", (ForwardExecType)0, 0, 0, 0);
+	MF_ExecuteForward(0, 0, 0);
+	MF_PrepareCellArray(NULL, 0);
+	MF_PrepareCharArray(NULL, 0);
+	MF_PrepareCellArrayA(NULL, 0, true);
+	MF_PrepareCharArrayA(NULL, 0, true);
+	MF_IsPlayerValid(0);
+	MF_GetPlayerName(0);
+	MF_GetPlayerIP(0);
+	MF_IsPlayerIngame(0);
+	MF_IsPlayerBot(0);
+	MF_IsPlayerAuthorized(0);
+	MF_GetPlayerTime(0);
+	MF_GetPlayerPlayTime(0);
+	MF_GetPlayerCurweapon(0);
+	MF_GetPlayerTeamID(0);
+	MF_GetPlayerTeam(0);
+	MF_GetPlayerDeaths(0);
+	MF_GetPlayerMenu(0);
+	MF_GetPlayerKeys(0);
+	MF_IsPlayerAlive(0);
+	MF_GetPlayerFrags(0);
+	MF_IsPlayerConnecting(0);
+	MF_IsPlayerHLTV(0);
+	MF_GetPlayerArmor(0);
+	MF_GetPlayerHealth(0);
+	MF_AmxExec(0, 0, 0, 0);
+	MF_AmxExecv(0, 0, 0, 0, 0);
+	MF_AmxFindPublic(0, 0, 0);
+	MF_AmxAllot(0, 0, 0, 0);
+	MF_LoadAmxScript(0, 0, 0, 0, 0);
+	MF_UnloadAmxScript(0, 0);
+	MF_RegisterSPForward(0, 0, 0, 0, 0, 0);
+	MF_RegisterSPForwardByName(0, 0, 0, 0, 0, 0);
+	MF_UnregisterSPForward(0);
+	MF_GetPlayerFrags(0);
+	MF_GetPlayerEdict(0);
+	MF_Format("", 4, "str");
+}
+#endif
+
+/************* MEMORY *************/
+// undef all defined macros
+#undef new
+#undef delete
+#undef malloc
+#undef calloc
+#undef realloc
+#undef free
+
+const		unsigned int	m_alloc_unknown        = 0;
+const		unsigned int	m_alloc_new            = 1;
+const		unsigned int	m_alloc_new_array      = 2;
+const		unsigned int	m_alloc_malloc         = 3;
+const		unsigned int	m_alloc_calloc         = 4;
+const		unsigned int	m_alloc_realloc        = 5;
+const		unsigned int	m_alloc_delete         = 6;
+const		unsigned int	m_alloc_delete_array   = 7;
+const		unsigned int	m_alloc_free           = 8;
+
+const char *g_Mem_CurrentFilename = "??";
+int g_Mem_CurrentLine = 0;
+const char *g_Mem_CurrentFunc = "??";
+
+const char *Mem_MakeSourceFile(const char *sourceFile)
+{
+	static char buffer[512];
+	static size_t pos = 0;
+	if (!pos)
+	{
+		// init
+		buffer[0] = '[';
+		strcpy(buffer + 1, MODULE_NAME);
+		pos = strlen(MODULE_NAME) + 1;
+		buffer[pos++] = ']';
+	}
+
+	// convert from absolute path to [modulename]filename
+	const char *ptr = strrchr(sourceFile, '\\');
+	if (ptr)
+		ptr++;
+	else
+	{
+		ptr = strrchr(sourceFile, '/');
+		if (ptr)
+			ptr++;
+		else
+			ptr = sourceFile;
+	}
+	strcpy(buffer + pos, ptr);
+	return buffer;
+}
+
+void Mem_SetOwner(const char *filename, int line, const char *function)
+{
+	g_Mem_CurrentFilename = filename;
+	g_Mem_CurrentLine = line;
+	g_Mem_CurrentFunc = function;
+}
+
+void Mem_ResetGlobals()
+{
+	Mem_SetOwner("??", 0, "??");
+}
+
+// raw (re/de)allocators
+void *	Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+			     const unsigned int allocationType, const size_t reportedSize)
+{
+	if (g_fn_Allocator)
+		return g_fn_Allocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, allocationType, reportedSize);
+	else
+		return malloc(reportedSize);
+}
+
+void *	Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+			       const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress)
+{
+	if (g_fn_Reallocator)
+		return g_fn_Reallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, reallocationType, reportedSize, reportedAddress);
+	else
+		return realloc(reportedAddress, reportedSize);
+}
+
+void	Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+			      const unsigned int deallocationType, void *reportedAddress)
+{
+	// If you you get user breakpoint here, something failed :)
+	//  - invalid pointer
+	//  - alloc type mismatch	( for example
+	//							char *a = new char[5]; delete char;
+	//							)
+	//  - The allocation unit is damaged (for example
+	//							char *a = new char[5]; a[6] = 8;
+	//							)
+	//  - break on dealloc flag set (somehow)
+
+	if (g_fn_Deallocator)
+		g_fn_Deallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, deallocationType, reportedAddress);
+	else
+		free(reportedAddress);
+}
+
+// new and delete operators
+void	*operator new(size_t reportedSize)
+{
+	if (reportedSize == 0)
+		reportedSize = 1;
+	void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize);
+	// :TODO: Handler support ?
+	if (ptr)
+		return ptr;
+
+	// allocation failed
+	return NULL;
+}
+
+void	*operator new[](size_t reportedSize)
+{
+	if (reportedSize == 0)
+		reportedSize = 1;
+	void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize);
+	// :TODO: Handler support ?
+	if (ptr)
+		return ptr;
+
+	// allocation failed
+	return NULL;
+}
+
+// Microsoft memory tracking operators
+void	*operator new(size_t reportedSize, const char *sourceFile, int sourceLine)
+{
+	if (reportedSize == 0)
+		reportedSize = 1;
+	void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize);
+	// :TODO: Handler support ?
+	if (ptr)
+		return ptr;
+
+	// allocation failed
+	return NULL;
+}
+void	*operator new[](size_t reportedSize, const char *sourceFile, int sourceLine)
+{
+	if (reportedSize == 0)
+		reportedSize = 1;
+	void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize);
+	// :TODO: Handler support ?
+	if (ptr)
+		return ptr;
+
+	// allocation failed
+	return NULL;
+}
+
+void	operator delete(void *reportedAddress)
+{
+	if (!reportedAddress)
+		return;
+
+	Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete, reportedAddress);
+}
+
+void	operator delete[](void *reportedAddress)
+{
+	if (!reportedAddress)
+		return;
+
+	Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete_array, reportedAddress);
+}
+
+/************* stuff from dlls/util.cpp *************/
+//				must come here because cbase.h declares it's own operator new
+
+#ifdef USE_METAMOD
+
+// Selected portions of dlls/util.cpp from SDK 2.1.
+// Functions copied from there as needed...
+// And modified to avoid buffer overflows (argh).
+
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+===== util.cpp ========================================================
+
+  Utility code.  Really not optional after all.
+
+*/
+
+#include <extdll.h>
+#include "sdk_util.h"
+#include <cbase.h>
+
+#include <string.h>			// for strncpy(), etc
+
+#include "osdep.h"			// win32 vsnprintf, etc
+
+char* UTIL_VarArgs( char *format, ... )
+{
+	va_list		argptr;
+	static char		string[1024];
+	
+	va_start (argptr, format);
+	vsnprintf (string, sizeof(string), format, argptr);
+	va_end (argptr);
+
+	return string;
+}
+	
+
+//=========================================================
+// UTIL_LogPrintf - Prints a logged message to console.
+// Preceded by LOG: ( timestamp ) < message >
+//=========================================================
+void UTIL_LogPrintf( char *fmt, ... )
+{
+	va_list			argptr;
+	static char		string[1024];
+	
+	va_start ( argptr, fmt );
+	vsnprintf ( string, sizeof(string), fmt, argptr );
+	va_end   ( argptr );
+
+	// Print to server console
+	ALERT( at_logged, "%s", string );
+}
+
+
+void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, 
+		const char *pMessage)
+{
+	if ( !pEntity )
+		return;
+
+	MESSAGE_BEGIN( MSG_ONE, SVC_TEMPENTITY, NULL, ENT(pEntity->pev) );
+		WRITE_BYTE( TE_TEXTMESSAGE );
+		WRITE_BYTE( textparms.channel & 0xFF );
+
+		WRITE_SHORT( FixedSigned16( textparms.x, 1<<13 ) );
+		WRITE_SHORT( FixedSigned16( textparms.y, 1<<13 ) );
+		WRITE_BYTE( textparms.effect );
+
+		WRITE_BYTE( textparms.r1 );
+		WRITE_BYTE( textparms.g1 );
+		WRITE_BYTE( textparms.b1 );
+		WRITE_BYTE( textparms.a1 );
+
+		WRITE_BYTE( textparms.r2 );
+		WRITE_BYTE( textparms.g2 );
+		WRITE_BYTE( textparms.b2 );
+		WRITE_BYTE( textparms.a2 );
+
+		WRITE_SHORT( FixedUnsigned16( textparms.fadeinTime, 1<<8 ) );
+		WRITE_SHORT( FixedUnsigned16( textparms.fadeoutTime, 1<<8 ) );
+		WRITE_SHORT( FixedUnsigned16( textparms.holdTime, 1<<8 ) );
+
+		if ( textparms.effect == 2 )
+			WRITE_SHORT( FixedUnsigned16( textparms.fxTime, 1<<8 ) );
+		
+		if ( strlen( pMessage ) < 512 )
+		{
+			WRITE_STRING( pMessage );
+		}
+		else
+		{
+			char tmp[512];
+			strncpy( tmp, pMessage, 511 );
+			tmp[511] = 0;
+			WRITE_STRING( tmp );
+		}
+	MESSAGE_END();
+}
+
+short FixedSigned16( float value, float scale )
+{
+	int output;
+
+	output = (int) (value * scale);
+
+	if ( output > 32767 )
+		output = 32767;
+
+	if ( output < -32768 )
+		output = -32768;
+
+	return (short)output;
+}
+
+unsigned short FixedUnsigned16( float value, float scale )
+{
+	int output;
+
+	output = (int) (value * scale);
+	if ( output < 0 )
+		output = 0;
+	if ( output > 0xFFFF )
+		output = 0xFFFF;
+
+	return (unsigned short)output;
+}
+#endif // USE_METAMOD
diff --git a/dlls/regex/amxxmodule.h b/dlls/regex/amxxmodule.h
new file mode 100755
index 00000000..e0b0e8fa
--- /dev/null
+++ b/dlls/regex/amxxmodule.h
@@ -0,0 +1,2197 @@
+/*
+ * AMX Mod X Module Interface Functions
+ * This file may be freely used
+*/
+
+// prevent double include
+#ifndef __AMXXMODULE_H__
+#define __AMXXMODULE_H__
+
+// config
+#include "moduleconfig.h"
+
+// metamod include files
+#ifdef USE_METAMOD
+#include <extdll.h>
+#include <meta_api.h>
+#include "osdep.h"
+#endif // #ifdef USE_METAMOD
+
+// DLL Export
+#undef DLLEXPORT
+#ifndef __linux__
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#define LINUX
+#endif
+
+#undef C_DLLEXPORT
+#define C_DLLEXPORT extern "C" DLLEXPORT
+
+// ***** AMXX stuff *****
+
+// module interface version is 1
+#define AMXX_INTERFACE_VERSION 1
+
+// amxx module info
+struct amxx_module_info_s
+{
+	const char *name;
+	const char *author;
+	const char *version;
+	int reload;				// reload on mapchange when nonzero
+};
+
+
+
+// return values from functions called by amxx
+#define AMXX_OK					0			/* no error */
+#define AMXX_IFVERS				1			/* interface version */
+#define AMXX_PARAM				2			/* Invalid parameter */
+#define AMXX_FUNC_NOT_PRESENT	3			/* Function not present */
+
+// *** Small stuff ***
+// The next section is copied from the amx.h file
+// Copyright (c) ITB CompuPhase, 1997-2004
+
+#if defined __LCC__ || defined __DMC__ || defined __linux__ || defined __GNUC__
+  #include <stdint.h>
+#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
+  /* The ISO C99 defines the int16_t and int_32t types. If the compiler got
+   * here, these types are probably undefined.
+   */
+  #if defined __FreeBSD__
+    #include <inttypes.h>
+  #else
+    typedef short int           int16_t;
+    typedef unsigned short int  uint16_t;
+    #if defined SN_TARGET_PS2
+      typedef int               int32_t;
+      typedef unsigned int      uint32_t;
+    #else
+      typedef long int          int32_t;
+      typedef unsigned long int uint32_t;
+    #endif
+    #if defined __WIN32__ || defined _WIN32 || defined WIN32
+      typedef __int64			int64_t;
+      typedef unsigned __int64	uint64_t;
+      #define HAVE_I64
+    #elif defined __GNUC__
+      typedef long long			int64_t;
+      typedef unsigned long long uint64_t;
+      #define HAVE_I64
+    #endif
+  #endif
+#endif
+
+
+/* calling convention for native functions */
+#if !defined AMX_NATIVE_CALL
+  #define AMX_NATIVE_CALL
+#endif
+/* calling convention for all interface functions and callback functions */
+#if !defined AMXAPI
+  #if defined STDECL
+    #define AMXAPI      __stdcall
+  #elif defined CDECL
+    #define AMXAPI      __cdecl
+  #else
+    #define AMXAPI
+  #endif
+#endif
+#if !defined AMXEXPORT
+  #define AMXEXPORT
+#endif
+
+
+
+#if !defined SMALL_CELL_SIZE
+  #define SMALL_CELL_SIZE 32    /* by default, use 32-bit cells */
+#endif
+#if SMALL_CELL_SIZE==32
+  typedef uint32_t  ucell;
+  typedef int32_t   cell;
+  typedef float		REAL;
+#elif SMALL_CELL_SIZE==64
+  typedef uint64_t  ucell;
+  typedef int64_t   cell;
+  typedef double	REAL;
+#else
+  #error Unsupported cell size (SMALL_CELL_SIZE)
+#endif
+
+#define UNPACKEDMAX   ((1 << (sizeof(cell)-1)*8) - 1)
+
+struct tagAMX;
+typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params);
+typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index,
+                                   cell *result, cell *params);
+typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
+#if !defined _FAR
+  #define _FAR
+#endif
+
+#if defined _MSC_VER
+  #pragma warning(disable:4103)  /* disable warning message 4103 that complains
+                                  * about pragma pack in a header file */
+  #pragma warning(disable:4100)  /* "'%$S' : unreferenced formal parameter" */
+#endif
+
+
+#if defined SN_TARGET_PS2 || defined __GNUC__
+  #define AMX_NO_ALIGN
+#endif
+
+
+#if defined __GNUC__
+  #define PACKED        __attribute__((packed))
+#else
+  #define PACKED
+#endif
+
+
+#if !defined AMX_NO_ALIGN
+  #if defined __linux__
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+  #else
+    #pragma pack(push)
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+    #if defined __TURBOC__
+      #pragma option -a-    /* "pack" pragma for older Borland compilers */
+    #endif
+  #endif
+#endif
+
+typedef struct {
+  const char _FAR *name PACKED;
+  AMX_NATIVE func       PACKED;
+} AMX_NATIVE_INFO;
+
+#define AMX_USERNUM     4
+
+/* The AMX structure is the internal structure for many functions. Not all
+ * fields are valid at all times; many fields are cached in local variables.
+ */
+typedef struct tagAMX {
+  unsigned char _FAR *base PACKED; /* points to the AMX header ("amxhdr") plus the code, optionally also the data */
+  unsigned char _FAR *data PACKED; /* points to separate data+stack+heap, may be NULL */
+  AMX_CALLBACK callback PACKED;
+  AMX_DEBUG debug       PACKED; /* debug callback */
+  /* for external functions a few registers must be accessible from the outside */
+  cell cip              PACKED; /* instruction pointer: relative to base + amxhdr->cod */
+  cell frm              PACKED; /* stack frame base: relative to base + amxhdr->dat */
+  cell hea              PACKED; /* top of the heap: relative to base + amxhdr->dat */
+  cell hlw              PACKED; /* bottom of the heap: relative to base + amxhdr->dat */
+  cell stk              PACKED; /* stack pointer: relative to base + amxhdr->dat */
+  cell stp              PACKED; /* top of the stack: relative to base + amxhdr->dat */
+  int flags             PACKED; /* current status, see amx_Flags() */
+  /* for assertions and debug hook */
+  cell curline          PACKED;
+  cell curfile          PACKED;
+  int dbgcode           PACKED;
+  cell dbgaddr          PACKED;
+  cell dbgparam         PACKED;
+  char _FAR *dbgname    PACKED;
+  /* user data */
+  long usertags[AMX_USERNUM] PACKED;
+  void _FAR *userdata[AMX_USERNUM] PACKED;
+  /* native functions can raise an error */
+  int error             PACKED;
+  /* the sleep opcode needs to store the full AMX status */
+  cell pri              PACKED;
+  cell alt              PACKED;
+  cell reset_stk        PACKED;
+  cell reset_hea        PACKED;
+  cell sysreq_d         PACKED; /* relocated address/value for the SYSREQ.D opcode */
+    /* support variables for the JIT */
+    int reloc_size      PACKED; /* required temporary buffer for relocations */
+    long code_size      PACKED; /* estimated memory footprint of the native code */
+} AMX;
+
+enum {
+  AMX_ERR_NONE,
+  /* reserve the first 15 error codes for exit codes of the abstract machine */
+  AMX_ERR_EXIT,         /* forced exit */
+  AMX_ERR_ASSERT,       /* assertion failed */
+  AMX_ERR_STACKERR,     /* stack/heap collision */
+  AMX_ERR_BOUNDS,       /* index out of bounds */
+  AMX_ERR_MEMACCESS,    /* invalid memory access */
+  AMX_ERR_INVINSTR,     /* invalid instruction */
+  AMX_ERR_STACKLOW,     /* stack underflow */
+  AMX_ERR_HEAPLOW,      /* heap underflow */
+  AMX_ERR_CALLBACK,     /* no callback, or invalid callback */
+  AMX_ERR_NATIVE,       /* native function failed */
+  AMX_ERR_DIVIDE,       /* divide by zero */
+  AMX_ERR_SLEEP,        /* go into sleepmode - code can be restarted */
+
+  AMX_ERR_MEMORY = 16,  /* out of memory */
+  AMX_ERR_FORMAT,       /* invalid file format */
+  AMX_ERR_VERSION,      /* file is for a newer version of the AMX */
+  AMX_ERR_NOTFOUND,     /* function not found */
+  AMX_ERR_INDEX,        /* invalid index parameter (bad entry point) */
+  AMX_ERR_DEBUG,        /* debugger cannot run */
+  AMX_ERR_INIT,         /* AMX not initialized (or doubly initialized) */
+  AMX_ERR_USERDATA,     /* unable to set user data field (table full) */
+  AMX_ERR_INIT_JIT,     /* cannot initialize the JIT */
+  AMX_ERR_PARAMS,       /* parameter error */
+  AMX_ERR_DOMAIN,       /* domain error, expression result does not fit in range */
+};
+
+#if !defined AMX_NO_ALIGN
+  #if defined __linux__
+    #pragma pack()    /* reset default packing */
+  #else
+    #pragma pack(pop) /* reset previous packing */
+  #endif
+#endif
+
+
+// ***** declare functions *****
+
+#ifdef USE_METAMOD
+void UTIL_LogPrintf( char *fmt, ... );
+void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, const char *pMessage);
+short FixedSigned16( float value, float scale );
+unsigned short FixedUnsigned16( float value, float scale );
+
+#ifdef FN_META_QUERY
+void FN_META_QUERY(void);
+#endif // FN_META_QUERY
+
+#ifdef FN_META_ATTACH
+void FN_META_ATTACH(void);
+#endif // FN_META_ATTACH
+
+#ifdef FN_META_DETACH
+void FN_META_DETACH(void);
+#endif // FN_META_DETACH
+
+
+
+
+
+#ifdef FN_GameDLLInit
+void FN_GameDLLInit(void);
+#endif // FN_GameDLLInit
+
+#ifdef FN_DispatchSpawn
+int FN_DispatchSpawn(edict_t *pent);
+#endif // FN_DispatchSpawn
+
+#ifdef FN_DispatchThink
+void FN_DispatchThink(edict_t *pent);
+#endif // FN_DispatchThink
+
+#ifdef FN_DispatchUse
+void FN_DispatchUse(edict_t *pentUser, edict_t *pentOther);
+#endif // FN_DispatchUse
+
+#ifdef FN_DispatchTouch
+void FN_DispatchTouch(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_DispatchTouch
+
+#ifdef FN_DispatchBlocked
+void FN_DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther);
+#endif // FN_DispatchBlocked
+
+#ifdef FN_DispatchKeyValue
+void FN_DispatchKeyValue(edict_t *pentKeyvalue, KeyValueData *pkvd);
+#endif // FN_DispatchKeyValue
+
+#ifdef FN_DispatchSave
+void FN_DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData);
+#endif // FN_DispatchSave
+
+#ifdef FN_DispatchRestore
+int FN_DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity);
+#endif // FN_DispatchRestore
+
+#ifdef FN_DispatchObjectCollsionBox
+void FN_DispatchObjectCollsionBox(edict_t *pent);
+#endif // FN_DispatchObjectCollsionBox
+
+#ifdef FN_SaveWriteFields
+void FN_SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveWriteFields
+
+#ifdef FN_SaveReadFields
+void FN_SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveReadFields
+
+#ifdef FN_SaveGlobalState
+void FN_SaveGlobalState(SAVERESTOREDATA *pSaveData);
+#endif // FN_SaveGlobalState
+
+#ifdef FN_RestoreGlobalState
+void FN_RestoreGlobalState(SAVERESTOREDATA *pSaveData);
+#endif // FN_RestoreGlobalState
+
+#ifdef FN_ResetGlobalState
+void FN_ResetGlobalState(void);
+#endif // FN_ResetGlobalState
+
+#ifdef FN_ClientConnect
+BOOL FN_ClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]);
+#endif // FN_ClientConnect
+
+#ifdef FN_ClientDisconnect
+void FN_ClientDisconnect(edict_t *pEntity);
+#endif // FN_ClientDisconnect
+
+#ifdef FN_ClientKill
+void FN_ClientKill(edict_t *pEntity);
+#endif // FN_ClientKill
+
+#ifdef FN_ClientPutInServer
+void FN_ClientPutInServer(edict_t *pEntity);
+#endif // FN_ClientPutInServer
+
+#ifdef FN_ClientCommand
+void FN_ClientCommand(edict_t *pEntity);
+#endif // FN_ClientCommand
+
+#ifdef FN_ClientUserInfoChanged
+void FN_ClientUserInfoChanged(edict_t *pEntity, char *infobuffer);
+#endif // FN_ClientUserInfoChanged
+
+#ifdef FN_ServerActivate
+void FN_ServerActivate(edict_t *pEdictList, int edictCount, int clientMax);
+#endif // FN_ServerActivate
+
+#ifdef FN_ServerDeactivate
+void FN_ServerDeactivate(void);
+#endif // FN_ServerDeactivate
+
+#ifdef FN_PlayerPreThink
+void FN_PlayerPreThink(edict_t *pEntity);
+#endif // FN_PlayerPreThink
+
+#ifdef FN_PlayerPostThink
+void FN_PlayerPostThink(edict_t *pEntity);
+#endif // FN_PlayerPostThink
+
+#ifdef FN_StartFrame
+void FN_StartFrame(void);
+#endif // FN_StartFrame
+
+#ifdef FN_ParmsNewLevel
+void FN_ParmsNewLevel(void);
+#endif // FN_ParmsNewLevel
+
+#ifdef FN_ParmsChangeLevel
+void FN_ParmsChangeLevel(void);
+#endif // FN_ParmsChangeLevel
+
+#ifdef FN_GetGameDescription
+const char *FN_GetGameDescription(void);
+#endif // FN_GetGameDescription
+
+#ifdef FN_PlayerCustomization
+void FN_PlayerCustomization(edict_t *pEntity, customization_t *pCust);
+#endif // FN_PlayerCustomization
+
+#ifdef FN_SpectatorConnect
+void FN_SpectatorConnect(edict_t *pEntity);
+#endif // FN_SpectatorConnect
+
+#ifdef FN_SpectatorDisconnect
+void FN_SpectatorDisconnect(edict_t *pEntity);
+#endif // FN_SpectatorDisconnect
+
+#ifdef FN_SpectatorThink
+void FN_SpectatorThink(edict_t *pEntity);
+#endif // FN_SpectatorThink
+
+#ifdef FN_Sys_Error
+void FN_Sys_Error(const char *error_string);
+#endif // FN_Sys_Error
+
+#ifdef FN_PM_Move
+void FN_PM_Move(struct playermove_s *ppmove, int server);
+#endif // FN_PM_Move
+
+#ifdef FN_PM_Init
+void FN_PM_Init(struct playermove_s *ppmove);
+#endif // FN_PM_Init
+
+#ifdef FN_PM_FindTextureType
+char FN_PM_FindTextureType(char *name);
+#endif // FN_PM_FindTextureType
+
+#ifdef FN_SetupVisibility
+void FN_SetupVisibility(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas);
+#endif // FN_SetupVisibility
+
+#ifdef FN_UpdateClientData
+void FN_UpdateClientData(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd);
+#endif // FN_UpdateClientData
+
+#ifdef FN_AddToFullPack
+int FN_AddToFullPack(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet);
+#endif // FN_AddToFullPack
+
+#ifdef FN_CreateBaseline
+void FN_CreateBaseline(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs);
+#endif // FN_CreateBaseline
+
+#ifdef FN_RegisterEncoders
+void FN_RegisterEncoders(void);
+#endif // FN_RegisterEncoders
+
+#ifdef FN_GetWeaponData
+int FN_GetWeaponData(struct edict_s *player, struct weapon_data_s *info);
+#endif // FN_GetWeaponData
+
+#ifdef FN_CmdStart
+void FN_CmdStart(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed);
+#endif // FN_CmdStart
+
+#ifdef FN_CmdEnd
+void FN_CmdEnd(const edict_t *player);
+#endif // FN_CmdEnd
+
+#ifdef FN_ConnectionlessPacket
+int FN_ConnectionlessPacket(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size);
+#endif // FN_ConnectionlessPacket
+
+#ifdef FN_GetHullBounds
+int FN_GetHullBounds(int hullnumber, float *mins, float *maxs);
+#endif // FN_GetHullBounds
+
+#ifdef FN_CreateInstancedBaselines
+void FN_CreateInstancedBaselines(void);
+#endif // FN_CreateInstancedBaselines
+
+#ifdef FN_InconsistentFile
+int FN_InconsistentFile(const edict_t *player, const char *filename, char *disconnect_message);
+#endif // FN_InconsistentFile
+
+#ifdef FN_AllowLagCompensation
+int FN_AllowLagCompensation(void);
+#endif // FN_AllowLagCompensation
+
+
+
+
+#ifdef FN_GameDLLInit_Post
+void FN_GameDLLInit_Post(void);
+#endif // FN_GameDLLInit_Post
+
+#ifdef FN_DispatchSpawn_Post
+int FN_DispatchSpawn_Post(edict_t *pent);
+#endif // FN_DispatchSpawn_Post
+
+#ifdef FN_DispatchThink_Post
+void FN_DispatchThink_Post(edict_t *pent);
+#endif // FN_DispatchThink_Post
+
+#ifdef FN_DispatchUse_Post
+void FN_DispatchUse_Post(edict_t *pentUser, edict_t *pentOther);
+#endif // FN_DispatchUse_Post
+
+#ifdef FN_DispatchTouch_Post
+void FN_DispatchTouch_Post(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_DispatchTouch_Post
+
+#ifdef FN_DispatchBlocked_Post
+void FN_DispatchBlocked_Post(edict_t *pentBlocked, edict_t *pentOther);
+#endif // FN_DispatchBlocked_Post
+
+#ifdef FN_DispatchKeyValue_Post
+void FN_DispatchKeyValue_Post(edict_t *pentKeyvalue, KeyValueData *pkvd);
+#endif // FN_DispatchKeyValue_Post
+
+#ifdef FN_DispatchSave_Post
+void FN_DispatchSave_Post(edict_t *pent, SAVERESTOREDATA *pSaveData);
+#endif // FN_DispatchSave_Post
+
+#ifdef FN_DispatchRestore_Post
+int FN_DispatchRestore_Post(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity);
+#endif // FN_DispatchRestore_Post
+
+#ifdef FN_DispatchObjectCollsionBox_Post
+void FN_DispatchObjectCollsionBox_Post(edict_t *pent);
+#endif // FN_DispatchObjectCollsionBox_Post
+
+#ifdef FN_SaveWriteFields_Post
+void FN_SaveWriteFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveWriteFields_Post
+
+#ifdef FN_SaveReadFields_Post
+void FN_SaveReadFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveReadFields_Post
+
+#ifdef FN_SaveGlobalState_Post
+void FN_SaveGlobalState_Post(SAVERESTOREDATA *pSaveData);
+#endif // FN_SaveGlobalState_Post
+
+#ifdef FN_RestoreGlobalState_Post
+void FN_RestoreGlobalState_Post(SAVERESTOREDATA *pSaveData);
+#endif // FN_RestoreGlobalState_Post
+
+#ifdef FN_ResetGlobalState_Post
+void FN_ResetGlobalState_Post(void);
+#endif // FN_ResetGlobalState_Post
+
+#ifdef FN_ClientConnect_Post
+BOOL FN_ClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]);
+#endif // FN_ClientConnect_Post
+
+#ifdef FN_ClientDisconnect_Post
+void FN_ClientDisconnect_Post(edict_t *pEntity);
+#endif // FN_ClientDisconnect_Post
+
+#ifdef FN_ClientKill_Post
+void FN_ClientKill_Post(edict_t *pEntity);
+#endif // FN_ClientKill_Post
+
+#ifdef FN_ClientPutInServer_Post
+void FN_ClientPutInServer_Post(edict_t *pEntity);
+#endif // FN_ClientPutInServer_Post
+
+#ifdef FN_ClientCommand_Post
+void FN_ClientCommand_Post(edict_t *pEntity);
+#endif // FN_ClientCommand_Post
+
+#ifdef FN_ClientUserInfoChanged_Post
+void FN_ClientUserInfoChanged_Post(edict_t *pEntity, char *infobuffer);
+#endif // FN_ClientUserInfoChanged_Post
+
+#ifdef FN_ServerActivate_Post
+void FN_ServerActivate_Post(edict_t *pEdictList, int edictCount, int clientMax);
+#endif // FN_ServerActivate_Post
+
+#ifdef FN_ServerDeactivate_Post
+void FN_ServerDeactivate_Post(void);
+#endif // FN_ServerDeactivate_Post
+
+#ifdef FN_PlayerPreThink_Post
+void FN_PlayerPreThink_Post(edict_t *pEntity);
+#endif // FN_PlayerPreThink_Post
+
+#ifdef FN_PlayerPostThink_Post
+void FN_PlayerPostThink_Post(edict_t *pEntity);
+#endif // FN_PlayerPostThink_Post
+
+#ifdef FN_StartFrame_Post
+void FN_StartFrame_Post(void);
+#endif // FN_StartFrame_Post
+
+#ifdef FN_ParmsNewLevel_Post
+void FN_ParmsNewLevel_Post(void);
+#endif // FN_ParmsNewLevel_Post
+
+#ifdef FN_ParmsChangeLevel_Post
+void FN_ParmsChangeLevel_Post(void);
+#endif // FN_ParmsChangeLevel_Post
+
+#ifdef FN_GetGameDescription_Post
+const char *FN_GetGameDescription_Post(void);
+#endif // FN_GetGameDescription_Post
+
+#ifdef FN_PlayerCustomization_Post
+void FN_PlayerCustomization_Post(edict_t *pEntity, customization_t *pCust);
+#endif // FN_PlayerCustomization_Post
+
+#ifdef FN_SpectatorConnect_Post
+void FN_SpectatorConnect_Post(edict_t *pEntity);
+#endif // FN_SpectatorConnect_Post
+
+#ifdef FN_SpectatorDisconnect_Post
+void FN_SpectatorDisconnect_Post(edict_t *pEntity);
+#endif // FN_SpectatorDisconnect_Post
+
+#ifdef FN_SpectatorThink_Post
+void FN_SpectatorThink_Post(edict_t *pEntity);
+#endif // FN_SpectatorThink_Post
+
+#ifdef FN_Sys_Error_Post
+void FN_Sys_Error_Post(const char *error_string);
+#endif // FN_Sys_Error_Post
+
+#ifdef FN_PM_Move_Post
+void FN_PM_Move_Post(struct playermove_s *ppmove, int server);
+#endif // FN_PM_Move_Post
+
+#ifdef FN_PM_Init_Post
+void FN_PM_Init_Post(struct playermove_s *ppmove);
+#endif // FN_PM_Init_Post
+
+#ifdef FN_PM_FindTextureType_Post
+char FN_PM_FindTextureType_Post(char *name);
+#endif // FN_PM_FindTextureType_Post
+
+#ifdef FN_SetupVisibility_Post
+void FN_SetupVisibility_Post(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas);
+#endif // FN_SetupVisibility_Post
+
+#ifdef FN_UpdateClientData_Post
+void FN_UpdateClientData_Post(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd);
+#endif // FN_UpdateClientData_Post
+
+#ifdef FN_AddToFullPack_Post
+int FN_AddToFullPack_Post(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet);
+#endif // FN_AddToFullPack_Post
+
+#ifdef FN_CreateBaseline_Post
+void FN_CreateBaseline_Post(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs);
+#endif // FN_CreateBaseline_Post
+
+#ifdef FN_RegisterEncoders_Post
+void FN_RegisterEncoders_Post(void);
+#endif // FN_RegisterEncoders_Post
+
+#ifdef FN_GetWeaponData_Post
+int FN_GetWeaponData_Post(struct edict_s *player, struct weapon_data_s *info);
+#endif // FN_GetWeaponData_Post
+
+#ifdef FN_CmdStart_Post
+void FN_CmdStart_Post(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed);
+#endif // FN_CmdStart_Post
+
+#ifdef FN_CmdEnd_Post
+void FN_CmdEnd_Post(const edict_t *player);
+#endif // FN_CmdEnd_Post
+
+#ifdef FN_ConnectionlessPacket_Post
+int FN_ConnectionlessPacket_Post(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size);
+#endif // FN_ConnectionlessPacket_Post
+
+#ifdef FN_GetHullBounds_Post
+int FN_GetHullBounds_Post(int hullnumber, float *mins, float *maxs);
+#endif // FN_GetHullBounds_Post
+
+#ifdef FN_CreateInstancedBaselines_Post
+void FN_CreateInstancedBaselines_Post(void);
+#endif // FN_CreateInstancedBaselines_Post
+
+#ifdef FN_InconsistentFile_Post
+int FN_InconsistentFile_Post(const edict_t *player, const char *filename, char *disconnect_message);
+#endif // FN_InconsistentFile_Post
+
+#ifdef FN_AllowLagCompensation_Post
+int FN_AllowLagCompensation_Post(void);
+#endif // FN_AllowLagCompensation_Post
+
+
+
+#ifdef FN_PrecacheModel
+int FN_PrecacheModel(char *s);
+#endif // FN_PrecacheModel
+
+#ifdef FN_PrecacheSound
+int FN_PrecacheSound(char *s);
+#endif // FN_PrecacheSound
+
+#ifdef FN_SetModel
+void FN_SetModel(edict_t *e, const char *m);
+#endif // FN_SetModel
+
+#ifdef FN_ModelIndex
+int FN_ModelIndex(const char *m);
+#endif // FN_ModelIndex
+
+#ifdef FN_ModelFrames
+int FN_ModelFrames(int modelIndex);
+#endif // FN_ModelFrames
+
+#ifdef FN_SetSize
+void FN_SetSize(edict_t *e, const float *rgflMin, const float *rgflMax);
+#endif // FN_SetSize
+
+#ifdef FN_ChangeLevel
+void FN_ChangeLevel(char *s1, char *s2);
+#endif // FN_ChangeLevel
+
+#ifdef FN_GetSpawnParms
+void FN_GetSpawnParms(edict_t *ent);
+#endif // FN_GetSpawnParms
+
+#ifdef FN_SaveSpawnParms
+void FN_SaveSpawnParms(edict_t *ent);
+#endif // FN_SaveSpawnParms
+
+#ifdef FN_VecToYaw
+float FN_VecToYaw(const float *rgflVector);
+#endif // FN_VecToYaw
+
+#ifdef FN_VecToAngles
+void FN_VecToAngles(const float *rgflVectorIn, float *rgflVectorOut);
+#endif // FN_VecToAngles
+
+#ifdef FN_MoveToOrigin
+void FN_MoveToOrigin(edict_t *ent, const float *pflGoal, float dist, int iMoveType);
+#endif // FN_MoveToOrigin
+
+#ifdef FN_ChangeYaw
+void FN_ChangeYaw(edict_t *ent);
+#endif // FN_ChangeYaw
+
+#ifdef FN_ChangePitch
+void FN_ChangePitch(edict_t *ent);
+#endif // FN_ChangePitch
+
+#ifdef FN_FindEntityByString
+edict_t *FN_FindEntityByString(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue);
+#endif // FN_FindEntityByString
+
+#ifdef FN_GetEntityIllum
+int FN_GetEntityIllum(edict_t *pEnt);
+#endif // FN_GetEntityIllum
+
+#ifdef FN_FindEntityInSphere
+edict_t *FN_FindEntityInSphere(edict_t *pEdictStartSearchAfter, const float *org, float rad);
+#endif // FN_FindEntityInSphere
+
+#ifdef FN_FindClientInPVS
+edict_t *FN_FindClientInPVS(edict_t *pEdict);
+#endif // FN_FindClientInPVS
+
+#ifdef FN_EntitiesInPVS
+edict_t *FN_EntitiesInPVS(edict_t *pplayer);
+#endif // FN_EntitiesInPVS
+
+#ifdef FN_MakeVectors
+void FN_MakeVectors(const float *rgflVector);
+#endif // FN_MakeVectors
+
+#ifdef FN_AngleVectors
+void FN_AngleVectors(const float *rgflVector, float *forward, float *right, float *up);
+#endif // FN_AngleVectors
+
+#ifdef FN_CreateEntity
+edict_t *FN_CreateEntity(void);
+#endif // FN_CreateEntity
+
+#ifdef FN_RemoveEntity
+void FN_RemoveEntity(edict_t *e);
+#endif // FN_RemoveEntity
+
+#ifdef FN_CreateNamedEntity
+edict_t *FN_CreateNamedEntity(int className);
+#endif // FN_CreateNamedEntity
+
+#ifdef FN_MakeStatic
+void FN_MakeStatic(edict_t *ent);
+#endif // FN_MakeStatic
+
+#ifdef FN_EntIsOnFloor
+int FN_EntIsOnFloor(edict_t *ent);
+#endif // FN_EntIsOnFloor
+
+#ifdef FN_DropToFloor
+int FN_DropToFloor(edict_t *ent);
+#endif // FN_DropToFloor
+
+#ifdef FN_WalkMove
+int FN_WalkMove(edict_t *ent, float yaw, float dist, int iMode);
+#endif // FN_WalkMove
+
+#ifdef FN_SetOrigin
+void FN_SetOrigin(edict_t *e, const float *rgflOrigin);
+#endif // FN_SetOrigin
+
+#ifdef FN_EmitSound
+void FN_EmitSound(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitSound
+
+#ifdef FN_EmitAmbientSound
+void FN_EmitAmbientSound(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitAmbientSound
+
+#ifdef FN_TraceLine
+void FN_TraceLine(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceLine
+
+#ifdef FN_TraceToss
+void FN_TraceToss(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr);
+#endif // FN_TraceToss
+
+#ifdef FN_TraceMonsterHull
+int FN_TraceMonsterHull(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceMonsterHull
+
+#ifdef FN_TraceHull
+void FN_TraceHull(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceHull
+
+#ifdef FN_TraceModel
+void FN_TraceModel(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr);
+#endif // FN_TraceModel
+
+#ifdef FN_TraceTexture
+const char *FN_TraceTexture(edict_t *pTextureEntity, const float *v1, const float *v2 );
+#endif // FN_TraceTexture
+
+#ifdef FN_TraceSphere
+void FN_TraceSphere(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceSphere
+
+#ifdef FN_GetAimVector
+void FN_GetAimVector(edict_t *ent, float speed, float *rgflReturn);
+#endif // FN_GetAimVector
+
+#ifdef FN_ServerCommand
+void FN_ServerCommand(char *str);
+#endif // FN_ServerCommand
+
+#ifdef FN_ServerExecute
+void FN_ServerExecute(void);
+#endif // FN_ServerExecute
+
+#ifdef FN_engClientCommand
+void FN_engClientCommand(edict_t *pEdict, char *szFmt, ...);
+#endif // FN_engClientCommand
+
+#ifdef FN_ParticleEffect
+void FN_ParticleEffect(const float *org, const float *dir, float color, float count);
+#endif // FN_ParticleEffect
+
+#ifdef FN_LightStyle
+void FN_LightStyle(int style, char *val);
+#endif // FN_LightStyle
+
+#ifdef FN_DecalIndex
+int FN_DecalIndex(const char *name);
+#endif // FN_DecalIndex
+
+#ifdef FN_PointContents
+int FN_PointContents(const float *rgflVector);
+#endif // FN_PointContents
+
+#ifdef FN_MessageBegin
+void FN_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_MessageBegin
+
+#ifdef FN_MessageEnd
+void FN_MessageEnd(void);
+#endif // FN_MessageEnd
+
+#ifdef FN_WriteByte
+void FN_WriteByte(int iValue);
+#endif // FN_WriteByte
+
+#ifdef FN_WriteChar
+void FN_WriteChar(int iValue);
+#endif // FN_WriteChar
+
+#ifdef FN_WriteShort
+void FN_WriteShort(int iValue);
+#endif // FN_WriteShort
+
+#ifdef FN_WriteLong
+void FN_WriteLong(int iValue);
+#endif // FN_WriteLong
+
+#ifdef FN_WriteAngle
+void FN_WriteAngle(float flValue);
+#endif // FN_WriteAngle
+
+#ifdef FN_WriteCoord
+void FN_WriteCoord(float flValue);
+#endif // FN_WriteCoord
+
+#ifdef FN_WriteString
+void FN_WriteString(const char *sz);
+#endif // FN_WriteString
+
+#ifdef FN_WriteEntity
+void FN_WriteEntity(int iValue);
+#endif // FN_WriteEntity
+
+#ifdef FN_CVarRegister
+void FN_CVarRegister(cvar_t *pCvar);
+#endif // FN_CVarRegister
+
+#ifdef FN_CVarGetFloat
+float FN_CVarGetFloat(const char *szVarName);
+#endif // FN_CVarGetFloat
+
+#ifdef FN_CVarGetString
+const char *FN_CVarGetString(const char *szVarName);
+#endif // FN_CVarGetString
+
+#ifdef FN_CVarSetFloat
+void FN_CVarSetFloat(const char *szVarName, float flValue);
+#endif // FN_CVarSetFloat
+
+#ifdef FN_CVarSetString
+void FN_CVarSetString(const char *szVarName, const char *szValue);
+#endif // FN_CVarSetString
+
+#ifdef FN_AlertMessage
+void FN_AlertMessage(ALERT_TYPE atype, char *szFmt, ...);
+#endif // FN_AlertMessage
+
+#ifdef FN_EngineFprintf
+void FN_EngineFprintf(FILE *pfile, char *szFmt, ...);
+#endif // FN_EngineFprintf
+
+#ifdef FN_PvAllocEntPrivateData
+void *FN_PvAllocEntPrivateData(edict_t *pEdict, int32 cb);
+#endif // FN_PvAllocEntPrivateData
+
+#ifdef FN_PvEntPrivateData
+void *FN_PvEntPrivateData(edict_t *pEdict);
+#endif // FN_PvEntPrivateData
+
+#ifdef FN_FreeEntPrivateData
+void FN_FreeEntPrivateData(edict_t *pEdict);
+#endif // FN_FreeEntPrivateData
+
+#ifdef FN_SzFromIndex
+const char *FN_SzFromIndex(int iString);
+#endif // FN_SzFromIndex
+
+#ifdef FN_AllocString
+int FN_AllocString(const char *szValue);
+#endif // FN_AllocString
+
+#ifdef FN_GetVarsOfEnt
+struct entvars_s *FN_GetVarsOfEnt(edict_t *pEdict);
+#endif // FN_GetVarsOfEnt
+
+#ifdef FN_PEntityOfEntOffset
+edict_t *FN_PEntityOfEntOffset(int iEntOffset);
+#endif // FN_PEntityOfEntOffset
+
+#ifdef FN_EntOffsetOfPEntity
+int FN_EntOffsetOfPEntity(const edict_t *pEdict);
+#endif // FN_EntOffsetOfPEntity
+
+#ifdef FN_IndexOfEdict
+int FN_IndexOfEdict(const edict_t *pEdict);
+#endif // FN_IndexOfEdict
+
+#ifdef FN_PEntityOfEntIndex
+edict_t *FN_PEntityOfEntIndex(int iEntIndex);
+#endif // FN_PEntityOfEntIndex
+
+#ifdef FN_FindEntityByVars
+edict_t *FN_FindEntityByVars(struct entvars_s *pvars);
+#endif // FN_FindEntityByVars
+
+#ifdef FN_GetModelPtr
+void *FN_GetModelPtr(edict_t *pEdict);
+#endif // FN_GetModelPtr
+
+#ifdef FN_RegUserMsg
+int FN_RegUserMsg(const char *pszName, int iSize);
+#endif // FN_RegUserMsg
+
+#ifdef FN_AnimationAutomove
+void FN_AnimationAutomove(const edict_t *pEdict, float flTime);
+#endif // FN_AnimationAutomove
+
+#ifdef FN_GetBonePosition
+void FN_GetBonePosition(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles);
+#endif // FN_GetBonePosition
+
+#ifdef FN_FunctionFromName
+unsigned long FN_FunctionFromName(const char *pName);
+#endif // FN_FunctionFromName
+
+#ifdef FN_NameForFunction
+const char *FN_NameForFunction(unsigned long function);
+#endif // FN_NameForFunction
+
+#ifdef FN_ClientPrintf
+void FN_ClientPrintf(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg);
+#endif // FN_ClientPrintf
+
+#ifdef FN_ServerPrint
+void FN_ServerPrint(const char *szMsg);
+#endif // FN_ServerPrint
+
+#ifdef FN_Cmd_Args
+const char *FN_Cmd_Args(void);
+#endif // FN_Cmd_Args
+
+#ifdef FN_Cmd_Argv
+const char *FN_Cmd_Argv(int argc);
+#endif // FN_Cmd_Argv
+
+#ifdef FN_Cmd_Argc
+int FN_Cmd_Argc(void);
+#endif // FN_Cmd_Argc
+
+#ifdef FN_GetAttachment
+void FN_GetAttachment(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles );
+#endif // FN_GetAttachment
+
+#ifdef FN_CRC32_Init
+void FN_CRC32_Init(CRC32_t *pulCRC);
+#endif // FN_CRC32_Init
+
+#ifdef FN_CRC32_ProcessBuffer
+void FN_CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len);
+#endif // FN_CRC32_ProcessBuffer
+
+#ifdef FN_CRC32_ProcessByte
+void FN_CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch);
+#endif // FN_CRC32_ProcessByte
+
+#ifdef FN_CRC32_Final
+CRC32_t FN_CRC32_Final(CRC32_t pulCRC);
+#endif // FN_CRC32_Final
+
+#ifdef FN_RandomLong
+long FN_RandomLong(long lLow, long lHigh);
+#endif // FN_RandomLong
+
+#ifdef FN_RandomFloat
+float FN_RandomFloat(float flLow, float flHigh);
+#endif // FN_RandomFloat
+
+#ifdef FN_SetView
+void FN_SetView(const edict_t *pClient, const edict_t *pViewent);
+#endif // FN_SetView
+
+#ifdef FN_Time
+float FN_Time(void);
+#endif // FN_Time
+
+#ifdef FN_CrosshairAngle
+void FN_CrosshairAngle(const edict_t *pClient, float pitch, float yaw);
+#endif // FN_CrosshairAngle
+
+#ifdef FN_LoadFileForMe
+byte *FN_LoadFileForMe(char *filename, int *pLength);
+#endif // FN_LoadFileForMe
+
+#ifdef FN_FreeFile
+void FN_FreeFile(void *buffer);
+#endif // FN_FreeFile
+
+#ifdef FN_EndSection
+void FN_EndSection(const char *pszSectionName);
+#endif // FN_EndSection
+
+#ifdef FN_CompareFileTime
+int FN_CompareFileTime(char *filename1, char *filename2, int *iCompare);
+#endif // FN_CompareFileTime
+
+#ifdef FN_GetGameDir
+void FN_GetGameDir(char *szGetGameDir);
+#endif // FN_GetGameDir
+
+#ifdef FN_Cvar_RegisterVariable
+void FN_Cvar_RegisterVariable(cvar_t *variable);
+#endif // FN_Cvar_RegisterVariable
+
+#ifdef FN_FadeClientVolume
+void FN_FadeClientVolume(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds);
+#endif // FN_FadeClientVolume
+
+#ifdef FN_SetClientMaxspeed
+void FN_SetClientMaxspeed(const edict_t *pEdict, float fNewMaxspeed);
+#endif // FN_SetClientMaxspeed
+
+#ifdef FN_CreateFakeClient
+edict_t *FN_CreateFakeClient(const char *netname);
+#endif // FN_CreateFakeClient
+
+#ifdef FN_RunPlayerMove
+void FN_RunPlayerMove(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec);
+#endif // FN_RunPlayerMove
+
+#ifdef FN_NumberOfEntities
+int FN_NumberOfEntities(void);
+#endif // FN_NumberOfEntities
+
+#ifdef FN_GetInfoKeyBuffer
+char *FN_GetInfoKeyBuffer(edict_t *e);
+#endif // FN_GetInfoKeyBuffer
+
+#ifdef FN_InfoKeyValue
+char *FN_InfoKeyValue(char *infobuffer, char *key);
+#endif // FN_InfoKeyValue
+
+#ifdef FN_SetKeyValue
+void FN_SetKeyValue(char *infobuffer, char *key, char *value);
+#endif // FN_SetKeyValue
+
+#ifdef FN_SetClientKeyValue
+void FN_SetClientKeyValue(int clientIndex, char *infobuffer, char *key, char *value);
+#endif // FN_SetClientKeyValue
+
+#ifdef FN_IsMapValid
+int FN_IsMapValid(char *filename);
+#endif // FN_IsMapValid
+
+#ifdef FN_StaticDecal
+void FN_StaticDecal(const float *origin, int decalIndex, int entityIndex, int modelIndex);
+#endif // FN_StaticDecal
+
+#ifdef FN_PrecacheGeneric
+int FN_PrecacheGeneric(char *s);
+#endif // FN_PrecacheGeneric
+
+#ifdef FN_GetPlayerUserId
+int FN_GetPlayerUserId(edict_t *e );
+#endif // FN_GetPlayerUserId
+
+#ifdef FN_BuildSoundMsg
+void FN_BuildSoundMsg(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_BuildSoundMsg
+
+#ifdef FN_IsDedicatedServer
+int FN_IsDedicatedServer(void);
+#endif // FN_IsDedicatedServer
+
+#ifdef FN_CVarGetPointer
+cvar_t *FN_CVarGetPointer(const char *szVarName);
+#endif // FN_CVarGetPointer
+
+#ifdef FN_GetPlayerWONId
+unsigned int FN_GetPlayerWONId(edict_t *e);
+#endif // FN_GetPlayerWONId
+
+#ifdef FN_Info_RemoveKey
+void FN_Info_RemoveKey( char *s, const char *key);
+#endif // FN_Info_RemoveKey
+
+#ifdef FN_GetPhysicsKeyValue
+const char *FN_GetPhysicsKeyValue(const edict_t *pClient, const char *key);
+#endif // FN_GetPhysicsKeyValue
+
+#ifdef FN_SetPhysicsKeyValue
+void FN_SetPhysicsKeyValue(const edict_t *pClient, const char *key, const char *value);
+#endif // FN_SetPhysicsKeyValue
+
+#ifdef FN_GetPhysicsInfoString
+const char *FN_GetPhysicsInfoString( const edict_t *pClient);
+#endif // FN_GetPhysicsInfoString
+
+#ifdef FN_PrecacheEvent
+unsigned short FN_PrecacheEvent(int type, const char *psz);
+#endif // FN_PrecacheEvent
+
+#ifdef FN_PlaybackEvent
+void FN_PlaybackEvent(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2);
+#endif // FN_PlaybackEvent
+
+#ifdef FN_SetFatPVS
+unsigned char *FN_SetFatPVS(float *org);
+#endif // FN_SetFatPVS
+
+#ifdef FN_SetFatPAS
+unsigned char *FN_SetFatPAS(float *org);
+#endif // FN_SetFatPAS
+
+#ifdef FN_CheckVisibility
+int FN_CheckVisibility(const edict_t *entity, unsigned char *pset);
+#endif // FN_CheckVisibility
+
+#ifdef FN_DeltaSetField
+void FN_DeltaSetField(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaSetField
+
+#ifdef FN_DeltaUnsetField
+void FN_DeltaUnsetField(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaUnsetField
+
+#ifdef FN_DeltaAddEncoder
+void FN_DeltaAddEncoder(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) );
+#endif // FN_DeltaAddEncoder
+
+#ifdef FN_GetCurrentPlayer
+int FN_GetCurrentPlayer(void);
+#endif // FN_GetCurrentPlayer
+
+#ifdef FN_CanSkipPlayer
+int FN_CanSkipPlayer(const edict_t *player);
+#endif // FN_CanSkipPlayer
+
+#ifdef FN_DeltaFindField
+int FN_DeltaFindField(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaFindField
+
+#ifdef FN_DeltaSetFieldByIndex
+void FN_DeltaSetFieldByIndex(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaSetFieldByIndex
+
+#ifdef FN_DeltaUnsetFieldByIndex
+void FN_DeltaUnsetFieldByIndex(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaUnsetFieldByIndex
+
+#ifdef FN_SetGroupMask
+void FN_SetGroupMask(int mask, int op);
+#endif // FN_SetGroupMask
+
+#ifdef FN_engCreateInstancedBaseline
+int FN_engCreateInstancedBaseline(int classname, struct entity_state_s *baseline);
+#endif // FN_engCreateInstancedBaseline
+
+#ifdef FN_Cvar_DirectSet
+void FN_Cvar_DirectSet(struct cvar_s *var, char *value);
+#endif // FN_Cvar_DirectSet
+
+#ifdef FN_ForceUnmodified
+void FN_ForceUnmodified(FORCE_TYPE type, float *mins, float *maxs, const char *filename);
+#endif // FN_ForceUnmodified
+
+#ifdef FN_GetPlayerStats
+void FN_GetPlayerStats(const edict_t *pClient, int *ping, int *packet_loss);
+#endif // FN_GetPlayerStats
+
+#ifdef FN_AddServerCommand
+void FN_AddServerCommand(char *cmd_name, void (*function) (void));
+#endif // FN_AddServerCommand
+
+#ifdef FN_Voice_GetClientListening
+qboolean FN_Voice_GetClientListening(int iReceiver, int iSender);
+#endif // FN_Voice_GetClientListening
+
+#ifdef FN_Voice_SetClientListening
+qboolean FN_Voice_SetClientListening(int iReceiver, int iSender, qboolean bListen);
+#endif // FN_Voice_SetClientListening
+
+#ifdef FN_GetPlayerAuthId
+const char *FN_GetPlayerAuthId(edict_t *e);
+#endif // FN_GetPlayerAuthId
+
+
+
+
+
+
+#ifdef FN_PrecacheModel_Post
+int FN_PrecacheModel_Post(char *s);
+#endif // FN_PrecacheModel_Post
+
+#ifdef FN_PrecacheSound_Post
+int FN_PrecacheSound_Post(char *s);
+#endif // FN_PrecacheSound_Post
+
+#ifdef FN_SetModel_Post
+void FN_SetModel_Post(edict_t *e, const char *m);
+#endif // FN_SetModel_Post
+
+#ifdef FN_ModelIndex_Post
+int FN_ModelIndex_Post(const char *m);
+#endif // FN_ModelIndex_Post
+
+#ifdef FN_ModelFrames_Post
+int FN_ModelFrames_Post(int modelIndex);
+#endif // FN_ModelFrames_Post
+
+#ifdef FN_SetSize_Post
+void FN_SetSize_Post(edict_t *e, const float *rgflMin, const float *rgflMax);
+#endif // FN_SetSize_Post
+
+#ifdef FN_ChangeLevel_Post
+void FN_ChangeLevel_Post(char *s1, char *s2);
+#endif // FN_ChangeLevel_Post
+
+#ifdef FN_GetSpawnParms_Post
+void FN_GetSpawnParms_Post(edict_t *ent);
+#endif // FN_GetSpawnParms_Post
+
+#ifdef FN_SaveSpawnParms_Post
+void FN_SaveSpawnParms_Post(edict_t *ent);
+#endif // FN_SaveSpawnParms_Post
+
+#ifdef FN_VecToYaw_Post
+float FN_VecToYaw_Post(const float *rgflVector);
+#endif // FN_VecToYaw_Post
+
+#ifdef FN_VecToAngles_Post
+void FN_VecToAngles_Post(const float *rgflVectorIn, float *rgflVectorOut);
+#endif // FN_VecToAngles_Post
+
+#ifdef FN_MoveToOrigin_Post
+void FN_MoveToOrigin_Post(edict_t *ent, const float *pflGoal, float dist, int iMoveType);
+#endif // FN_MoveToOrigin_Post
+
+#ifdef FN_ChangeYaw_Post
+void FN_ChangeYaw_Post(edict_t *ent);
+#endif // FN_ChangeYaw_Post
+
+#ifdef FN_ChangePitch_Post
+void FN_ChangePitch_Post(edict_t *ent);
+#endif // FN_ChangePitch_Post
+
+#ifdef FN_FindEntityByString_Post
+edict_t *FN_FindEntityByString_Post(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue);
+#endif // FN_FindEntityByString_Post
+
+#ifdef FN_GetEntityIllum_Post
+int FN_GetEntityIllum_Post(edict_t *pEnt);
+#endif // FN_GetEntityIllum_Post
+
+#ifdef FN_FindEntityInSphere_Post
+edict_t *FN_FindEntityInSphere_Post(edict_t *pEdictStartSearchAfter, const float *org, float rad);
+#endif // FN_FindEntityInSphere_Post
+
+#ifdef FN_FindClientInPVS_Post
+edict_t *FN_FindClientInPVS_Post(edict_t *pEdict);
+#endif // FN_FindClientInPVS_Post
+
+#ifdef FN_EntitiesInPVS_Post
+edict_t *FN_EntitiesInPVS_Post(edict_t *pplayer);
+#endif // FN_EntitiesInPVS_Post
+
+#ifdef FN_MakeVectors_Post
+void FN_MakeVectors_Post(const float *rgflVector);
+#endif // FN_MakeVectors_Post
+
+#ifdef FN_AngleVectors_Post
+void FN_AngleVectors_Post(const float *rgflVector, float *forward, float *right, float *up);
+#endif // FN_AngleVectors_Post
+
+#ifdef FN_CreateEntity_Post
+edict_t *FN_CreateEntity_Post(void);
+#endif // FN_CreateEntity_Post
+
+#ifdef FN_RemoveEntity_Post
+void FN_RemoveEntity_Post(edict_t *e);
+#endif // FN_RemoveEntity_Post
+
+#ifdef FN_CreateNamedEntity_Post
+edict_t *FN_CreateNamedEntity_Post(int className);
+#endif // FN_CreateNamedEntity_Post
+
+#ifdef FN_MakeStatic_Post
+void FN_MakeStatic_Post(edict_t *ent);
+#endif // FN_MakeStatic_Post
+
+#ifdef FN_EntIsOnFloor_Post
+int FN_EntIsOnFloor_Post(edict_t *ent);
+#endif // FN_EntIsOnFloor_Post
+
+#ifdef FN_DropToFloor_Post
+int FN_DropToFloor_Post(edict_t *ent);
+#endif // FN_DropToFloor_Post
+
+#ifdef FN_WalkMove_Post
+int FN_WalkMove_Post(edict_t *ent, float yaw, float dist, int iMode);
+#endif // FN_WalkMove_Post
+
+#ifdef FN_SetOrigin_Post
+void FN_SetOrigin_Post(edict_t *e, const float *rgflOrigin);
+#endif // FN_SetOrigin_Post
+
+#ifdef FN_EmitSound_Post
+void FN_EmitSound_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitSound_Post
+
+#ifdef FN_EmitAmbientSound_Post
+void FN_EmitAmbientSound_Post(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitAmbientSound_Post
+
+#ifdef FN_TraceLine_Post
+void FN_TraceLine_Post(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceLine_Post
+
+#ifdef FN_TraceToss_Post
+void FN_TraceToss_Post(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr);
+#endif // FN_TraceToss_Post
+
+#ifdef FN_TraceMonsterHull_Post
+int FN_TraceMonsterHull_Post(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceMonsterHull_Post
+
+#ifdef FN_TraceHull_Post
+void FN_TraceHull_Post(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceHull_Post
+
+#ifdef FN_TraceModel_Post
+void FN_TraceModel_Post(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr);
+#endif // FN_TraceModel_Post
+
+#ifdef FN_TraceTexture_Post
+const char *FN_TraceTexture_Post(edict_t *pTextureEntity, const float *v1, const float *v2 );
+#endif // FN_TraceTexture_Post
+
+#ifdef FN_TraceSphere_Post
+void FN_TraceSphere_Post(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceSphere_Post
+
+#ifdef FN_GetAimVector_Post
+void FN_GetAimVector_Post(edict_t *ent, float speed, float *rgflReturn);
+#endif // FN_GetAimVector_Post
+
+#ifdef FN_ServerCommand_Post
+void FN_ServerCommand_Post(char *str);
+#endif // FN_ServerCommand_Post
+
+#ifdef FN_ServerExecute_Post
+void FN_ServerExecute_Post(void);
+#endif // FN_ServerExecute_Post
+
+#ifdef FN_engClientCommand_Post
+void FN_engClientCommand_Post(edict_t *pEdict, char *szFmt, ...);
+#endif // FN_engClientCommand_Post
+
+#ifdef FN_ParticleEffect_Post
+void FN_ParticleEffect_Post(const float *org, const float *dir, float color, float count);
+#endif // FN_ParticleEffect_Post
+
+#ifdef FN_LightStyle_Post
+void FN_LightStyle_Post(int style, char *val);
+#endif // FN_LightStyle_Post
+
+#ifdef FN_DecalIndex_Post
+int FN_DecalIndex_Post(const char *name);
+#endif // FN_DecalIndex_Post
+
+#ifdef FN_PointContents_Post
+int FN_PointContents_Post(const float *rgflVector);
+#endif // FN_PointContents_Post
+
+#ifdef FN_MessageBegin_Post
+void FN_MessageBegin_Post(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_MessageBegin_Post
+
+#ifdef FN_MessageEnd_Post
+void FN_MessageEnd_Post(void);
+#endif // FN_MessageEnd_Post
+
+#ifdef FN_WriteByte_Post
+void FN_WriteByte_Post(int iValue);
+#endif // FN_WriteByte_Post
+
+#ifdef FN_WriteChar_Post
+void FN_WriteChar_Post(int iValue);
+#endif // FN_WriteChar_Post
+
+#ifdef FN_WriteShort_Post
+void FN_WriteShort_Post(int iValue);
+#endif // FN_WriteShort_Post
+
+#ifdef FN_WriteLong_Post
+void FN_WriteLong_Post(int iValue);
+#endif // FN_WriteLong_Post
+
+#ifdef FN_WriteAngle_Post
+void FN_WriteAngle_Post(float flValue);
+#endif // FN_WriteAngle_Post
+
+#ifdef FN_WriteCoord_Post
+void FN_WriteCoord_Post(float flValue);
+#endif // FN_WriteCoord_Post
+
+#ifdef FN_WriteString_Post
+void FN_WriteString_Post(const char *sz);
+#endif // FN_WriteString_Post
+
+#ifdef FN_WriteEntity_Post
+void FN_WriteEntity_Post(int iValue);
+#endif // FN_WriteEntity_Post
+
+#ifdef FN_CVarRegister_Post
+void FN_CVarRegister_Post(cvar_t *pCvar);
+#endif // FN_CVarRegister_Post
+
+#ifdef FN_CVarGetFloat_Post
+float FN_CVarGetFloat_Post(const char *szVarName);
+#endif // FN_CVarGetFloat_Post
+
+#ifdef FN_CVarGetString_Post
+const char *FN_CVarGetString_Post(const char *szVarName);
+#endif // FN_CVarGetString_Post
+
+#ifdef FN_CVarSetFloat_Post
+void FN_CVarSetFloat_Post(const char *szVarName, float flValue);
+#endif // FN_CVarSetFloat_Post
+
+#ifdef FN_CVarSetString_Post
+void FN_CVarSetString_Post(const char *szVarName, const char *szValue);
+#endif // FN_CVarSetString_Post
+
+#ifdef FN_AlertMessage_Post
+void FN_AlertMessage_Post(ALERT_TYPE atype, char *szFmt, ...);
+#endif // FN_AlertMessage_Post
+
+#ifdef FN_EngineFprintf_Post
+void FN_EngineFprintf_Post(FILE *pfile, char *szFmt, ...);
+#endif // FN_EngineFprintf_Post
+
+#ifdef FN_PvAllocEntPrivateData_Post
+void *FN_PvAllocEntPrivateData_Post(edict_t *pEdict, long cb);
+#endif // FN_PvAllocEntPrivateData_Post
+
+#ifdef FN_PvEntPrivateData_Post
+void *FN_PvEntPrivateData_Post(edict_t *pEdict);
+#endif // FN_PvEntPrivateData_Post
+
+#ifdef FN_FreeEntPrivateData_Post
+void FN_FreeEntPrivateData_Post(edict_t *pEdict);
+#endif // FN_FreeEntPrivateData_Post
+
+#ifdef FN_SzFromIndex_Post
+const char *FN_SzFromIndex_Post(int iString);
+#endif // FN_SzFromIndex_Post
+
+#ifdef FN_AllocString_Post
+int FN_AllocString_Post(const char *szValue);
+#endif // FN_AllocString_Post
+
+#ifdef FN_GetVarsOfEnt_Post
+struct entvars_s *FN_GetVarsOfEnt_Post(edict_t *pEdict);
+#endif // FN_GetVarsOfEnt_Post
+
+#ifdef FN_PEntityOfEntOffset_Post
+edict_t *FN_PEntityOfEntOffset_Post(int iEntOffset);
+#endif // FN_PEntityOfEntOffset_Post
+
+#ifdef FN_EntOffsetOfPEntity_Post
+int FN_EntOffsetOfPEntity_Post(const edict_t *pEdict);
+#endif // FN_EntOffsetOfPEntity_Post
+
+#ifdef FN_IndexOfEdict_Post
+int FN_IndexOfEdict_Post(const edict_t *pEdict);
+#endif // FN_IndexOfEdict_Post
+
+#ifdef FN_PEntityOfEntIndex_Post
+edict_t *FN_PEntityOfEntIndex_Post(int iEntIndex);
+#endif // FN_PEntityOfEntIndex_Post
+
+#ifdef FN_FindEntityByVars_Post
+edict_t *FN_FindEntityByVars_Post(struct entvars_s *pvars);
+#endif // FN_FindEntityByVars_Post
+
+#ifdef FN_GetModelPtr_Post
+void *FN_GetModelPtr_Post(edict_t *pEdict);
+#endif // FN_GetModelPtr_Post
+
+#ifdef FN_RegUserMsg_Post
+int FN_RegUserMsg_Post(const char *pszName, int iSize);
+#endif // FN_RegUserMsg_Post
+
+#ifdef FN_AnimationAutomove_Post
+void FN_AnimationAutomove_Post(const edict_t *pEdict, float flTime);
+#endif // FN_AnimationAutomove_Post
+
+#ifdef FN_GetBonePosition_Post
+void FN_GetBonePosition_Post(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles);
+#endif // FN_GetBonePosition_Post
+
+#ifdef FN_FunctionFromName_Post
+unsigned long FN_FunctionFromName_Post(const char *pName);
+#endif // FN_FunctionFromName_Post
+
+#ifdef FN_NameForFunction_Post
+const char *FN_NameForFunction_Post(unsigned long function);
+#endif // FN_NameForFunction_Post
+
+#ifdef FN_ClientPrintf_Post
+void FN_ClientPrintf_Post(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg);
+#endif // FN_ClientPrintf_Post
+
+#ifdef FN_ServerPrint_Post
+void FN_ServerPrint_Post(const char *szMsg);
+#endif // FN_ServerPrint_Post
+
+#ifdef FN_Cmd_Args_Post
+const char *FN_Cmd_Args_Post(void);
+#endif // FN_Cmd_Args_Post
+
+#ifdef FN_Cmd_Argv_Post
+const char *FN_Cmd_Argv_Post(int argc);
+#endif // FN_Cmd_Argv_Post
+
+#ifdef FN_Cmd_Argc_Post
+int FN_Cmd_Argc_Post(void);
+#endif // FN_Cmd_Argc_Post
+
+#ifdef FN_GetAttachment_Post
+void FN_GetAttachment_Post(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles );
+#endif // FN_GetAttachment_Post
+
+#ifdef FN_CRC32_Init_Post
+void FN_CRC32_Init_Post(CRC32_t *pulCRC);
+#endif // FN_CRC32_Init_Post
+
+#ifdef FN_CRC32_ProcessBuffer_Post
+void FN_CRC32_ProcessBuffer_Post(CRC32_t *pulCRC, void *p, int len);
+#endif // FN_CRC32_ProcessBuffer_Post
+
+#ifdef FN_CRC32_ProcessByte_Post
+void FN_CRC32_ProcessByte_Post(CRC32_t *pulCRC, unsigned char ch);
+#endif // FN_CRC32_ProcessByte_Post
+
+#ifdef FN_CRC32_Final_Post
+CRC32_t FN_CRC32_Final_Post(CRC32_t pulCRC);
+#endif // FN_CRC32_Final_Post
+
+#ifdef FN_RandomLong_Post
+long FN_RandomLong_Post(long lLow, long lHigh);
+#endif // FN_RandomLong_Post
+
+#ifdef FN_RandomFloat_Post
+float FN_RandomFloat_Post(float flLow, float flHigh);
+#endif // FN_RandomFloat_Post
+
+#ifdef FN_SetView_Post
+void FN_SetView_Post(const edict_t *pClient, const edict_t *pViewent);
+#endif // FN_SetView_Post
+
+#ifdef FN_Time_Post
+float FN_Time_Post(void);
+#endif // FN_Time_Post
+
+#ifdef FN_CrosshairAngle_Post
+void FN_CrosshairAngle_Post(const edict_t *pClient, float pitch, float yaw);
+#endif // FN_CrosshairAngle_Post
+
+#ifdef FN_LoadFileForMe_Post
+byte *FN_LoadFileForMe_Post(char *filename, int *pLength);
+#endif // FN_LoadFileForMe_Post
+
+#ifdef FN_FreeFile_Post
+void FN_FreeFile_Post(void *buffer);
+#endif // FN_FreeFile_Post
+
+#ifdef FN_EndSection_Post
+void FN_EndSection_Post(const char *pszSectionName);
+#endif // FN_EndSection_Post
+
+#ifdef FN_CompareFileTime_Post
+int FN_CompareFileTime_Post(char *filename1, char *filename2, int *iCompare);
+#endif // FN_CompareFileTime_Post
+
+#ifdef FN_GetGameDir_Post
+void FN_GetGameDir_Post(char *szGetGameDir);
+#endif // FN_GetGameDir_Post
+
+#ifdef FN_Cvar_RegisterVariable_Post
+void FN_Cvar_RegisterVariable_Post(cvar_t *variable);
+#endif // FN_Cvar_RegisterVariable_Post
+
+#ifdef FN_FadeClientVolume_Post
+void FN_FadeClientVolume_Post(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds);
+#endif // FN_FadeClientVolume_Post
+
+#ifdef FN_SetClientMaxspeed_Post
+void FN_SetClientMaxspeed_Post(const edict_t *pEdict, float fNewMaxspeed);
+#endif // FN_SetClientMaxspeed_Post
+
+#ifdef FN_CreateFakeClient_Post
+edict_t *FN_CreateFakeClient_Post(const char *netname);
+#endif // FN_CreateFakeClient_Post
+
+#ifdef FN_RunPlayerMove_Post
+void FN_RunPlayerMove_Post(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec);
+#endif // FN_RunPlayerMove_Post
+
+#ifdef FN_NumberOfEntities_Post
+int FN_NumberOfEntities_Post(void);
+#endif // FN_NumberOfEntities_Post
+
+#ifdef FN_GetInfoKeyBuffer_Post
+char *FN_GetInfoKeyBuffer_Post(edict_t *e);
+#endif // FN_GetInfoKeyBuffer_Post
+
+#ifdef FN_InfoKeyValue_Post
+char *FN_InfoKeyValue_Post(char *infobuffer, char *key);
+#endif // FN_InfoKeyValue_Post
+
+#ifdef FN_SetKeyValue_Post
+void FN_SetKeyValue_Post(char *infobuffer, char *key, char *value);
+#endif // FN_SetKeyValue_Post
+
+#ifdef FN_SetClientKeyValue_Post
+void FN_SetClientKeyValue_Post(int clientIndex, char *infobuffer, char *key, char *value);
+#endif // FN_SetClientKeyValue_Post
+
+#ifdef FN_IsMapValid_Post
+int FN_IsMapValid_Post(char *filename);
+#endif // FN_IsMapValid_Post
+
+#ifdef FN_StaticDecal_Post
+void FN_StaticDecal_Post(const float *origin, int decalIndex, int entityIndex, int modelIndex);
+#endif // FN_StaticDecal_Post
+
+#ifdef FN_PrecacheGeneric_Post
+int FN_PrecacheGeneric_Post(char *s);
+#endif // FN_PrecacheGeneric_Post
+
+#ifdef FN_GetPlayerUserId_Post
+int FN_GetPlayerUserId_Post(edict_t *e );
+#endif // FN_GetPlayerUserId_Post
+
+#ifdef FN_BuildSoundMsg_Post
+void FN_BuildSoundMsg_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_BuildSoundMsg_Post
+
+#ifdef FN_IsDedicatedServer_Post
+int FN_IsDedicatedServer_Post(void);
+#endif // FN_IsDedicatedServer_Post
+
+#ifdef FN_CVarGetPointer_Post
+cvar_t *FN_CVarGetPointer_Post(const char *szVarName);
+#endif // FN_CVarGetPointer_Post
+
+#ifdef FN_GetPlayerWONId_Post
+unsigned int FN_GetPlayerWONId_Post(edict_t *e);
+#endif // FN_GetPlayerWONId_Post
+
+#ifdef FN_Info_RemoveKey_Post
+void FN_Info_RemoveKey_Post( char *s, const char *key);
+#endif // FN_Info_RemoveKey_Post
+
+#ifdef FN_GetPhysicsKeyValue_Post
+const char *FN_GetPhysicsKeyValue_Post(const edict_t *pClient, const char *key);
+#endif // FN_GetPhysicsKeyValue_Post
+
+#ifdef FN_SetPhysicsKeyValue_Post
+void FN_SetPhysicsKeyValue_Post(const edict_t *pClient, const char *key, const char *value);
+#endif // FN_SetPhysicsKeyValue_Post
+
+#ifdef FN_GetPhysicsInfoString_Post
+const char *FN_GetPhysicsInfoString_Post( const edict_t *pClient);
+#endif // FN_GetPhysicsInfoString_Post
+
+#ifdef FN_PrecacheEvent_Post
+unsigned short FN_PrecacheEvent_Post(int type, const char *psz);
+#endif // FN_PrecacheEvent_Post
+
+#ifdef FN_PlaybackEvent_Post
+void FN_PlaybackEvent_Post(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2);
+#endif // FN_PlaybackEvent_Post
+
+#ifdef FN_SetFatPVS_Post
+unsigned char *FN_SetFatPVS_Post(float *org);
+#endif // FN_SetFatPVS_Post
+
+#ifdef FN_SetFatPAS_Post
+unsigned char *FN_SetFatPAS_Post(float *org);
+#endif // FN_SetFatPAS_Post
+
+#ifdef FN_CheckVisibility_Post
+int FN_CheckVisibility_Post(const edict_t *entity, unsigned char *pset);
+#endif // FN_CheckVisibility_Post
+
+#ifdef FN_DeltaSetField_Post
+void FN_DeltaSetField_Post(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaSetField_Post
+
+#ifdef FN_DeltaUnsetField_Post
+void FN_DeltaUnsetField_Post(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaUnsetField_Post
+
+#ifdef FN_DeltaAddEncoder_Post
+void FN_DeltaAddEncoder_Post(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) );
+#endif // FN_DeltaAddEncoder_Post
+
+#ifdef FN_GetCurrentPlayer_Post
+int FN_GetCurrentPlayer_Post(void);
+#endif // FN_GetCurrentPlayer_Post
+
+#ifdef FN_CanSkipPlayer_Post
+int FN_CanSkipPlayer_Post(const edict_t *player);
+#endif // FN_CanSkipPlayer_Post
+
+#ifdef FN_DeltaFindField_Post
+int FN_DeltaFindField_Post(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaFindField_Post
+
+#ifdef FN_DeltaSetFieldByIndex_Post
+void FN_DeltaSetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaSetFieldByIndex_Post
+
+#ifdef FN_DeltaUnsetFieldByIndex_Post
+void FN_DeltaUnsetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaUnsetFieldByIndex_Post
+
+#ifdef FN_SetGroupMask_Post
+void FN_SetGroupMask_Post(int mask, int op);
+#endif // FN_SetGroupMask_Post
+
+#ifdef FN_engCreateInstancedBaseline_Post
+int FN_engCreateInstancedBaseline_Post(int classname, struct entity_state_s *baseline);
+#endif // FN_engCreateInstancedBaseline_Post
+
+#ifdef FN_Cvar_DirectSet_Post
+void FN_Cvar_DirectSet_Post(struct cvar_s *var, char *value);
+#endif // FN_Cvar_DirectSet_Post
+
+#ifdef FN_ForceUnmodified_Post
+void FN_ForceUnmodified_Post(FORCE_TYPE type, float *mins, float *maxs, const char *filename);
+#endif // FN_ForceUnmodified_Post
+
+#ifdef FN_GetPlayerStats_Post
+void FN_GetPlayerStats_Post(const edict_t *pClient, int *ping, int *packet_loss);
+#endif // FN_GetPlayerStats_Post
+
+#ifdef FN_AddServerCommand_Post
+void FN_AddServerCommand_Post(char *cmd_name, void (*function)(void));
+#endif // FN_AddServerCommand_Post
+
+#ifdef FN_Voice_GetClientListening_Post
+qboolean FN_Voice_GetClientListening_Post(int iReceiver, int iSender);
+#endif // FN_Voice_GetClientListening_Post
+
+#ifdef FN_Voice_SetClientListening_Post
+qboolean FN_Voice_SetClientListening_Post(int iReceiver, int iSender, qboolean bListen);
+#endif // FN_Voice_SetClientListening_Post
+
+#ifdef FN_GetPlayerAuthId_Post
+const char *FN_GetPlayerAuthId_Post(edict_t *e);
+#endif // FN_GetPlayerAuthId
+
+
+
+
+#ifdef FN_OnFreeEntPrivateData
+void FN_OnFreeEntPrivateData(edict_t *pEnt);
+#endif // FN_OnFreeEntPrivateData
+
+#ifdef FN_GameShutdown
+void FN_GameShutdown(void);
+#endif // FN_GameShutdown
+
+#ifdef FN_ShouldCollide
+int FN_ShouldCollide(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_ShouldCollide
+
+
+
+
+
+#ifdef FN_OnFreeEntPrivateData_Post
+void FN_OnFreeEntPrivateData_Post(edict_t *pEnt);
+#endif // FN_OnFreeEntPrivateData_Post
+
+#ifdef FN_GameShutdown_Post
+void FN_GameShutdown_Post(void);
+#endif // FN_GameShutdown_Post
+
+#ifdef FN_ShouldCollide_Post
+int FN_ShouldCollide_Post(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_ShouldCollide_Post
+
+#endif // USE_METAMOD
+
+
+#ifdef FN_AMXX_QUERY
+void FN_AMXX_QUERY(void);
+#endif // FN_AMXX_QUERY
+
+#ifdef FN_AMXX_ATTACH
+void FN_AMXX_ATTACH(void);
+#endif // FN_AMXX_ATTACH
+
+#ifdef FN_AMXX_DETACH
+void FN_AMXX_DETACH(void);
+#endif // FN_AMXX_DETACH
+
+#ifdef FN_AMXX_PLUGINSLOADED
+void FN_AMXX_PLUGINSLOADED(void);
+#endif // FN_AMXX_PLUGINSLOADED
+
+// ***** Module funcs stuff *****
+enum ForwardExecType
+{
+	ET_IGNORE = 0,					// Ignore return vaue
+	ET_STOP,						// Stop on PLUGIN_HANDLED
+	ET_STOP2,						// Stop on PLUGIN_HANDLED, continue on other values, return biggest return value
+	ET_CONTINUE,					// Continue; return biggest return value
+};
+
+enum ForwardParam
+{
+	FP_DONE = -1,					// specify this as the last argument
+									// only tells the function that there are no more arguments
+	FP_CELL,						// normal cell
+	FP_FLOAT,						// float; used as normal cell though
+	FP_STRING,						// string
+	FP_STRINGEX,					// string; will be updated to the last function's value
+	FP_ARRAY,						// array; use the return value of prepareArray.
+};
+
+
+typedef int				(*PFN_ADD_NATIVES)				(const AMX_NATIVE_INFO * /*list*/);
+typedef char *			(*PFN_BUILD_PATHNAME)			(const char * /*format*/, ...);
+typedef cell *			(*PFN_GET_AMXADDR)				(AMX * /*amx*/, cell /*offset*/);
+typedef void			(*PFN_PRINT_SRVCONSOLE)			(char * /*format*/, ...);
+typedef const char *	(*PFN_GET_MODNAME)				(void);
+typedef const char *	(*PFN_GET_AMXSCRIPTNAME)		(int /*id*/);
+typedef AMX *			(*PFN_GET_AMXSCRIPT)			(int /*id*/);
+typedef int				(*PFN_FIND_AMXSCRIPT_BYAMX)		(const AMX * /*amx*/);
+typedef int				(*PFN_FIND_AMXSCRIPT_BYNAME)	(const char * /*name*/);
+typedef int				(*PFN_SET_AMXSTRING)			(AMX * /*amx*/, cell /*amx_addr*/, const char * /* source */, int /* max */);
+typedef char *			(*PFN_GET_AMXSTRING)			(AMX * /*amx*/, cell /*amx_addr*/, int /*bufferId*/, int * /*pLen*/);
+typedef int				(*PFN_GET_AMXSTRINGLEN)			(const cell *ptr);
+typedef char *			(*PFN_FORMAT_AMXSTRING)			(AMX * /*amx*/, cell * /*params*/, int /*startParam*/, int * /*pLen*/);
+typedef void			(*PFN_COPY_AMXMEMORY)			(cell * /*dest*/, const cell * /*src*/, int /*len*/);
+typedef void			(*PFN_LOG)						(const char * /*fmt*/, ...);
+typedef void			(*PFN_LOG_ERROR)				(AMX * /*amx*/, int /*err*/, const char * /*fmt*/, ...);
+typedef int				(*PFN_RAISE_AMXERROR)			(AMX * /*amx*/, int /*error*/);
+typedef int				(*PFN_REGISTER_FORWARD)			(const char * /*funcname*/, ForwardExecType /*exectype*/, ... /*paramtypes terminated by PF_DONE*/);
+typedef int				(*PFN_EXECUTE_FORWARD)			(int /*id*/, ... /*params*/);
+typedef cell			(*PFN_PREPARE_CELLARRAY)		(cell * /*ptr*/, unsigned int /*size*/);
+typedef cell			(*PFN_PREPARE_CHARARRAY)		(char * /*ptr*/, unsigned int /*size*/);
+typedef cell			(*PFN_PREPARE_CELLARRAY_A)		(cell * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/);
+typedef cell			(*PFN_PREPARE_CHARARRAY_A)		(char * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/);
+typedef int				(*PFN_IS_PLAYER_VALID)			(int /*id*/);
+typedef const char *	(*PFN_GET_PLAYER_NAME)			(int /*id*/);
+typedef const char *	(*PFN_GET_PLAYER_IP)			(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_INGAME)			(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_BOT)			(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_AUTHORIZED)		(int /*id*/);
+typedef float			(*PFN_GET_PLAYER_TIME)			(int /*id*/);
+typedef float			(*PFN_GET_PLAYER_PLAYTIME)		(int /*id*/);
+typedef int				(*PFN_GETPLAYERFLAGS) 			(int /* id*/);
+typedef int				(*PFN_GET_PLAYER_CURWEAPON)		(int /*id*/);
+typedef const char *    (*PFN_GET_PLAYER_TEAM)			(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_TEAMID)		(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_DEATHS)		(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_MENU)			(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_KEYS)			(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_ALIVE)			(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_FRAGS)			(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_CONNECTING)		(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_HLTV)			(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_ARMOR)			(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_HEALTH)		(int /*id*/);
+#ifdef USE_METAMOD
+typedef edict_t *		(*PFN_GET_PLAYER_EDICT)			(int /*id*/);
+#else
+typedef void *			(*PFN_GET_PLAYER_EDICT)			(int /*id*/);
+#endif
+
+typedef void *			(*PFN_ALLOCATOR)				(const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
+														 const unsigned int /*type*/, const size_t /*size*/);
+typedef void *			(*PFN_REALLOCATOR)				(const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
+														 const unsigned int /*type*/, const size_t /*size*/, void* /*addr*/ );
+typedef void			(*PFN_DEALLOCATOR)				(const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
+														 const unsigned int /*type*/, const void* /*addr*/ );
+typedef int				(*PFN_AMX_EXEC)					(AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, ... /*params*/);
+typedef int				(*PFN_AMX_EXECV)				(AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, cell[] /*params*/);
+typedef int				(*PFN_AMX_ALLOT)				(AMX* /*amx*/, int /*length*/, cell* /*amx_addr*/, cell** /*phys_addr*/);
+typedef int				(*PFN_AMX_FINDPUBLIC)			(AMX* /*amx*/, char* /*func name*/, int* /*index*/);
+typedef int				(*PFN_AMX_FINDNATIVE)			(AMX* /*amx*/, char* /*func name*/, int* /*index*/);
+typedef int				(*PFN_LOAD_AMXSCRIPT)			(AMX* /*amx*/, void** /*code*/, const char* /*path*/, char[64] /*error info*/, int /* debug */);
+typedef int				(*PFN_UNLOAD_AMXSCRIPT)			(AMX* /*amx*/,void** /*code*/);
+typedef cell			(*PFN_REAL_TO_CELL)				(REAL /*x*/);
+typedef REAL			(*PFN_CELL_TO_REAL)				(cell /*x*/);
+typedef int				(*PFN_REGISTER_SPFORWARD)		(AMX * /*amx*/, int /*func*/, ... /*params*/);
+typedef int				(*PFN_REGISTER_SPFORWARD_BYNAME)	(AMX * /*amx*/, const char * /*funcName*/, ... /*params*/);
+typedef void			(*PFN_UNREGISTER_SPFORWARD)		(int /*id*/);
+typedef	void			(*PFN_MERGEDEFINITION_FILE)		(const char * /*filename*/);
+typedef const char *	(*PFN_FORMAT)					(const char * /*fmt*/, ... /*params*/);
+
+extern PFN_ADD_NATIVES				g_fn_AddNatives;
+extern PFN_BUILD_PATHNAME			g_fn_BuildPathname;
+extern PFN_GET_AMXADDR				g_fn_GetAmxAddr;
+extern PFN_PRINT_SRVCONSOLE			g_fn_PrintSrvConsole;
+extern PFN_GET_MODNAME				g_fn_GetModname;
+extern PFN_GET_AMXSCRIPTNAME		g_fn_GetAmxScriptName;
+extern PFN_GET_AMXSCRIPT			g_fn_GetAmxScript;
+extern PFN_FIND_AMXSCRIPT_BYAMX		g_fn_FindAmxScriptByAmx;
+extern PFN_FIND_AMXSCRIPT_BYNAME	g_fn_FindAmxScriptByName;
+extern PFN_SET_AMXSTRING			g_fn_SetAmxString;
+extern PFN_GET_AMXSTRING			g_fn_GetAmxString;
+extern PFN_GET_AMXSTRINGLEN			g_fn_GetAmxStringLen;
+extern PFN_FORMAT_AMXSTRING			g_fn_FormatAmxString;
+extern PFN_COPY_AMXMEMORY			g_fn_CopyAmxMemory;
+extern PFN_LOG						g_fn_Log;
+extern PFN_LOG_ERROR				g_fn_LogErrorFunc;
+extern PFN_RAISE_AMXERROR			g_fn_RaiseAmxError;
+extern PFN_REGISTER_FORWARD			g_fn_RegisterForward;
+extern PFN_EXECUTE_FORWARD			g_fn_ExecuteForward;
+extern PFN_PREPARE_CELLARRAY		g_fn_PrepareCellArray;
+extern PFN_PREPARE_CHARARRAY		g_fn_PrepareCharArray;
+extern PFN_PREPARE_CELLARRAY_A		g_fn_PrepareCellArrayA;
+extern PFN_PREPARE_CHARARRAY_A		g_fn_PrepareCharArrayA;
+extern PFN_IS_PLAYER_VALID			g_fn_IsPlayerValid;
+extern PFN_GET_PLAYER_NAME			g_fn_GetPlayerName;
+extern PFN_GET_PLAYER_IP			g_fn_GetPlayerIP;
+extern PFN_IS_PLAYER_INGAME			g_fn_IsPlayerIngame;
+extern PFN_IS_PLAYER_BOT			g_fn_IsPlayerBot;
+extern PFN_IS_PLAYER_AUTHORIZED		g_fn_IsPlayerAuthorized;
+extern PFN_GET_PLAYER_TIME			g_fn_GetPlayerTime;
+extern PFN_GET_PLAYER_PLAYTIME		g_fn_GetPlayerPlayTime;
+extern PFN_GET_PLAYER_CURWEAPON		g_fn_GetPlayerCurweapon;
+extern PFN_GET_PLAYER_TEAMID		g_fn_GetPlayerTeamID;
+extern PFN_GET_PLAYER_DEATHS		g_fn_GetPlayerDeaths;
+extern PFN_GET_PLAYER_MENU			g_fn_GetPlayerMenu;
+extern PFN_GET_PLAYER_KEYS			g_fn_GetPlayerKeys;
+extern PFN_IS_PLAYER_ALIVE			g_fn_IsPlayerAlive;
+extern PFN_GET_PLAYER_FRAGS			g_fn_GetPlayerFrags;
+extern PFN_IS_PLAYER_CONNECTING		g_fn_IsPlayerConnecting;
+extern PFN_IS_PLAYER_HLTV			g_fn_IsPlayerHLTV;
+extern PFN_GET_PLAYER_ARMOR			g_fn_GetPlayerArmor;
+extern PFN_GET_PLAYER_HEALTH		g_fn_GetPlayerHealth;
+extern PFN_AMX_EXEC					g_fn_AmxExec;
+extern PFN_AMX_EXECV				g_fn_AmxExecv;
+extern PFN_AMX_ALLOT				g_fn_AmxAllot;
+extern PFN_AMX_FINDPUBLIC			g_fn_AmxFindPublic;
+extern PFN_LOAD_AMXSCRIPT			g_fn_LoadAmxScript;
+extern PFN_UNLOAD_AMXSCRIPT			g_fn_UnloadAmxScript;
+extern PFN_REAL_TO_CELL				g_fn_RealToCell;
+extern PFN_CELL_TO_REAL				g_fn_CellToReal;
+extern PFN_REGISTER_SPFORWARD		g_fn_RegisterSPForward;
+extern PFN_REGISTER_SPFORWARD_BYNAME	g_fn_RegisterSPForwardByName;
+extern PFN_UNREGISTER_SPFORWARD		g_fn_UnregisterSPForward;
+extern PFN_MERGEDEFINITION_FILE		g_fn_MergeDefinition_File;
+extern PFN_AMX_FINDNATIVE			g_fn_AmxFindNative;
+extern PFN_GETPLAYERFLAGS		g_fn_GetPlayerFlags;
+extern PFN_GET_PLAYER_EDICT			g_fn_GetPlayerEdict;
+extern PFN_FORMAT					g_fn_Format;
+extern PFN_GET_PLAYER_TEAM			g_fn_GetPlayerTeam;
+
+#ifdef MAY_NEVER_BE_DEFINED
+// Function prototypes for intellisense and similar systems
+// They understand #if 0 so we use #ifdef MAY_NEVER_BE_DEFINED
+int				MF_AddNatives				(const AMX_NATIVE_INFO *list) { }
+char *			MF_BuildPathname			(const char * format, ...) { }
+cell *			MF_GetAmxAddr				(AMX * amx, cell offset) { }
+void			MF_PrintSrvConsole			(char * format, ...) { }
+const char *	MF_GetModname				(void) { }
+const char *	MF_GetScriptName			(int id) { }
+AMX *			MF_GetScriptAmx				(int id) { }
+int				MF_FindScriptByAmx			(const AMX * amx) { }
+int				MF_FindScriptByAmx			(const char * name) { }
+int				MF_SetAmxString				(AMX * amx, cell amx_addr, const char *  source , int  max ) { }
+char *			MF_GetAmxString				(AMX * amx, cell amx_addr, int bufferId, int * pLen) { }
+int				MF_GetAmxStringLen			(const cell *ptr) { }
+char *			MF_FormatAmxString			(AMX * amx, cell * params, int startParam, int * pLen) { }
+void			MF_CopyAmxMemory			(cell * dest, const cell * src, int len) { }
+void			MF_Log						(const char * fmt, ...) { }
+void			MF_LogError					(AMX * amx, int err, const char *fmt, ...) { }
+int				MF_RaiseAmxError			(AMX * amx, int error) { }
+int				MF_RegisterForward			(const char * funcname, ForwardExecType exectype, ...) { }
+int				MF_ExecuteForward			(int id, ...) { }
+cell			MF_PrepareCellArray			(cell * ptr, unsigned int size) { }
+cell			MF_PrepareCharArray			(char * ptr, unsigned int size) { }
+cell			MF_PrepareCellArrayA			(cell * ptr, unsigned int size, bool copyBack) { }
+cell			MF_PrepareCharArrayA			(char * ptr, unsigned int size, bool copyBack) { }
+int				MF_IsPlayerValid			(int id) { }
+const char *	MF_GetPlayerName			(int id) { }
+const char *	MF_GetPlayerIP				(int id) { }
+int				MF_IsPlayerIngame			(int id) { }
+int				MF_IsPlayerBot				(int id) { }
+int				MF_IsPlayerAuthorized		(int id) { }
+float			MF_GetPlayerTime			(int id) { }
+float			MF_GetPlayerPlayTime		(int id) { }
+int				MF_GetPlayerCurweapon		(int id) { }
+const char *	MF_GetPlayerTeam			(int id) { }
+int				MF_GetPlayerTeamID			(int id) { }
+int				MF_GetPlayerDeaths			(int id) { }
+int				MF_GetPlayerMenu			(int id) { }
+int				MF_GetPlayerKeys			(int id) { }
+int				MF_IsPlayerAlive			(int id) { }
+int				MF_GetPlayerFrags			(int id) { }
+int				MF_IsPlayerConnecting		(int id) { }
+int				MF_IsPlayerHLTV				(int id) { }
+int				MF_GetPlayerArmor			(int id) { }
+int				MF_GetPlayerHealth			(int id) { }
+REAL			amx_ctof					(cell x) { }
+cell			amx_ftoc					(float x) { }
+int				MF_RegisterSPForwardByName	(AMX * amx, const char *str, ...) { }
+int				MF_RegisterSPForward		(AMX * amx, int func, ...) { }
+void			MF_UnregisterSPForward		(int id) { }
+int				MF_GetPlayerFlags			(int id) { }
+edict_t*		MF_GetPlayerEdict			(int id) { }
+const char *	MF_Format					(const char *fmt, ...) { }
+#endif	// MAY_NEVER_BE_DEFINED
+
+#define MF_AddNatives g_fn_AddNatives
+#define MF_BuildPathname g_fn_BuildPathname
+#define MF_FormatAmxString g_fn_FormatAmxString
+#define MF_GetAmxAddr g_fn_GetAmxAddr
+#define MF_PrintSrvConsole g_fn_PrintSrvConsole
+#define MF_GetModname g_fn_GetModname
+#define MF_GetScriptName g_fn_GetAmxScriptName
+#define MF_GetScriptAmx g_fn_GetAmxScript
+#define MF_FindScriptByAmx g_fn_FindAmxScriptByAmx
+#define MF_FindScriptByName g_fn_FindAmxScriptByName
+#define MF_SetAmxString g_fn_SetAmxString
+#define MF_GetAmxString g_fn_GetAmxString
+#define MF_GetAmxStringLen g_fn_GetAmxStringLen
+#define MF_CopyAmxMemory g_fn_CopyAmxMemory
+void MF_Log(const char *fmt, ...);
+void MF_LogError(AMX *amx, int err, const char *fmt, ...);
+#define MF_RaiseAmxError g_fn_RaiseAmxError
+#define MF_RegisterForward g_fn_RegisterForward
+#define MF_ExecuteForward g_fn_ExecuteForward
+#define MF_PrepareCellArray g_fn_PrepareCellArray
+#define MF_PrepareCharArray g_fn_PrepareCharArray
+#define MF_PrepareCellArrayA g_fn_PrepareCellArrayA
+#define MF_PrepareCharArrayA g_fn_PrepareCharArrayA
+#define MF_IsPlayerValid g_fn_IsPlayerValid
+#define MF_GetPlayerName g_fn_GetPlayerName
+#define MF_GetPlayerIP g_fn_GetPlayerIP
+#define MF_IsPlayerIngame g_fn_IsPlayerIngame
+#define MF_IsPlayerBot g_fn_IsPlayerBot
+#define MF_IsPlayerAuthorized g_fn_IsPlayerAuthorized
+#define MF_GetPlayerTime g_fn_GetPlayerTime
+#define MF_GetPlayerPlayTime g_fn_GetPlayerPlayTime
+#define MF_GetPlayerCurweapon g_fn_GetPlayerCurweapon
+#define MF_GetPlayerTeam g_fn_GetPlayerTeam
+#define MF_GetPlayerTeamID g_fn_GetPlayerTeamID
+#define MF_GetPlayerDeaths g_fn_GetPlayerDeaths
+#define MF_GetPlayerMenu g_fn_GetPlayerMenu
+#define MF_GetPlayerKeys g_fn_GetPlayerKeys
+#define MF_IsPlayerAlive g_fn_IsPlayerAlive
+#define MF_GetPlayerFrags g_fn_GetPlayerFrags
+#define MF_IsPlayerConnecting g_fn_IsPlayerConnecting
+#define MF_IsPlayerHLTV g_fn_IsPlayerHLTV
+#define MF_GetPlayerArmor g_fn_GetPlayerArmor
+#define MF_GetPlayerHealth g_fn_GetPlayerHealth
+#define MF_AmxExec g_fn_AmxExec
+#define MF_AmxExecv g_fn_AmxExecv
+#define MF_AmxFindPublic g_fn_AmxFindPublic
+#define MF_AmxAllot g_fn_AmxAllot
+#define MF_AmxFindNative g_fn_AmxFindNative
+#define MF_LoadAmxScript g_fn_LoadAmxScript
+#define MF_UnloadAmxScript g_fn_UnloadAmxScript
+#define MF_MergeDefinitionFile g_fn_MergeDefinition_File
+#define amx_ctof g_fn_CellToReal
+#define amx_ftoc g_fn_RealToCell
+#define MF_RegisterSPForwardByName g_fn_RegisterSPForwardByName
+#define MF_RegisterSPForward g_fn_RegisterSPForward
+#define MF_UnregisterSPForward g_fn_UnregisterSPForward
+#define MF_GetPlayerFlags g_fn_GetPlayerFlags
+#define MF_GetPlayerEdict g_fn_GetPlayerEdict
+#define MF_Format g_fn_Format
+
+/*** Memory ***/
+void	*operator new(size_t reportedSize);
+void	*operator new[](size_t reportedSize);
+void	*operator new(size_t reportedSize, const char *sourceFile, int sourceLine);
+void	*operator new[](size_t reportedSize, const char *sourceFile, int sourceLine);
+void	operator delete(void *reportedAddress);
+void	operator delete[](void *reportedAddress);
+
+// Allocation types
+extern	const	unsigned int	m_alloc_unknown;
+extern	const	unsigned int	m_alloc_new;
+extern	const	unsigned int	m_alloc_new_array;
+extern	const	unsigned int	m_alloc_malloc;
+extern	const	unsigned int	m_alloc_calloc;
+extern	const	unsigned int	m_alloc_realloc;
+extern	const	unsigned int	m_alloc_delete;
+extern	const	unsigned int	m_alloc_delete_array;
+extern	const	unsigned int	m_alloc_free;
+
+// To be called before new / delete
+void	Mem_SetOwner(const char *filename, int line, const char *function);
+// Actual allocator
+void *	Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+					const unsigned int allocationType, const size_t reportedSize);
+void *	Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+					const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress);
+void	Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+					const unsigned int deallocationType, void *reportedAddress);
+
+// memory macros
+#ifndef __FUNCTION__
+#define __FUNCTION__ "??"
+#endif
+
+// call Mem_SetOwner, followed by the actual new operator
+#define	new			(Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? NULL : new
+// call Mem_SetOwner, followed by the actual delete operator
+#define	delete		(Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? Mem_SetOwner("",0,"") : delete
+#define	malloc(sz)	Mem_Allocator  (__FILE__,__LINE__,__FUNCTION__,m_alloc_malloc,sz)
+#define	calloc(sz)	Mem_Allocator  (__FILE__,__LINE__,__FUNCTION__,m_alloc_calloc,sz)
+#define	realloc(ptr,sz)	Mem_Reallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_realloc,sz,ptr)
+#define	free(ptr)	Mem_Deallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_free,ptr)
+
+#endif // #ifndef __AMXXMODULE_H__
diff --git a/dlls/regex/lib_win/pcre.lib b/dlls/regex/lib_win/pcre.lib
new file mode 100755
index 0000000000000000000000000000000000000000..ffaa4a0066eed90aa049de1720c53b4b77ad9c7a
GIT binary patch
literal 120740
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

literal 0
HcmV?d00001

diff --git a/dlls/regex/lib_win/pcreposix.lib b/dlls/regex/lib_win/pcreposix.lib
new file mode 100755
index 0000000000000000000000000000000000000000..7723d635a4a73da57f7208fe8782e76fa07fe17b
GIT binary patch
literal 26892
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
F0svf&|E>T4

literal 0
HcmV?d00001

diff --git a/dlls/regex/module.cpp b/dlls/regex/module.cpp
new file mode 100755
index 00000000..ee3a0996
--- /dev/null
+++ b/dlls/regex/module.cpp
@@ -0,0 +1,104 @@
+#include <string.h>
+#include "pcre.h"
+#include "CVector.h"
+#include "CRegEx.h"
+#include "amxxmodule.h"
+#include "module.h"
+
+CVector<RegEx *> PEL;
+
+int GetPEL()
+{
+	for (int i=0; i<(int)PEL.size(); i++)
+	{
+		if (PEL[i]->isFree())
+			return i;
+	}
+
+	RegEx *x = new RegEx();
+	PEL.push_back(x);
+
+	return (int)PEL.size() - 1;
+}
+
+static cell AMX_NATIVE_CALL regex_match(AMX *amx, cell *params)
+{
+	int len;
+	const char *str = MF_GetAmxString(amx, params[1], 0, &len);
+	const char *regex = MF_GetAmxString(amx, params[2], 1, &len);
+
+	int id = GetPEL();
+	RegEx *x = PEL[id];
+	
+	if (x->Compile(regex) == 0)
+	{
+		cell *eOff = MF_GetAmxAddr(amx, params[3]);
+		const char *err = x->mError;
+		*eOff = x->mErrorOffset;
+		MF_SetAmxString(amx, params[4], err?err:"unknown", params[5]);
+		return 0;
+	}
+
+	int e = x->Match(str);
+	if (e == -1)
+	{
+		/* there was a match error.  destroy this and move on. */
+		cell *res = MF_GetAmxAddr(amx, params[3]);
+		*res = x->mErrorOffset;
+		x->Clear();
+		return -1;
+	} else {
+		cell *res = MF_GetAmxAddr(amx, params[3]);
+		*res = x->mSubStrings;
+	}
+
+	return id+1;
+}
+
+static cell AMX_NATIVE_CALL regex_substr(AMX *amx, cell *params)
+{
+	int id = params[1];
+	if (id >= (int)PEL.size() || id < 0 || PEL[id]->isFree())
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid regex handle %d", id);
+		return 0;
+	}
+
+	RegEx *x = PEL[id];
+	//good idea? probably not.
+	static char buffer[4096];
+
+	const char *ret = x->GetSubstring(params[2], buffer, 4095);
+
+	if (ret == NULL)
+		return 0;
+
+	MF_SetAmxString(amx, params[3], ret, params[4]);
+
+	return 1;
+}
+
+AMX_NATIVE_INFO regex_Natives[] = {
+	{"regex_match",				regex_match},
+	{"regex_substr",			regex_substr},
+	{NULL,						NULL},
+};
+
+void OnAmxxAttach()
+{
+	MF_AddNatives(regex_Natives);
+}
+
+void OnAmxxDetach()
+{
+	for (int i = 0; i<(int)PEL.size(); i++)
+	{
+		if (PEL[i])
+		{
+			delete PEL[i];
+			PEL[i] = 0;
+		}
+	}
+
+	PEL.clear();
+}
\ No newline at end of file
diff --git a/dlls/regex/module.h b/dlls/regex/module.h
new file mode 100755
index 00000000..2221b410
--- /dev/null
+++ b/dlls/regex/module.h
@@ -0,0 +1,10 @@
+/* (C)2004 David "BAILOPAN" anderosn
+ * Licensed under the GNU General Public License, version 2
+ */
+
+#ifndef _INCLUDE_REGEX_H
+#define _INCLUDE_REGEX_H
+
+
+
+#endif //_INCLUDE_REGEX_H
\ No newline at end of file
diff --git a/dlls/regex/moduleconfig.h b/dlls/regex/moduleconfig.h
new file mode 100755
index 00000000..67e486c4
--- /dev/null
+++ b/dlls/regex/moduleconfig.h
@@ -0,0 +1,462 @@
+// Configuration
+
+#ifndef __MODULECONFIG_H__
+#define __MODULECONFIG_H__
+
+// Module info
+#define MODULE_NAME "RegEx"
+#define MODULE_VERSION "1.00"
+#define MODULE_AUTHOR "BAILOPAN"
+#define MODULE_URL "http://www.amxmodx.org/"
+#define MODULE_LOGTAG "REGEX"
+// If you want the module not to be reloaded on mapchange, remove / comment out the next line
+#define MODULE_RELOAD_ON_MAPCHANGE
+
+#ifdef __DATE__
+#define MODULE_DATE __DATE__
+#else // __DATE__
+#define MODULE_DATE "Unknown"
+#endif // __DATE__
+
+// metamod plugin?
+// #define USE_METAMOD
+
+// - AMXX Init functions
+// Also consider using FN_META_*
+// AMXX query
+//#define FN_AMXX_QUERY OnAmxxQuery
+// AMXX attach
+//   Do native functions init here (MF_AddNatives)
+#define FN_AMXX_ATTACH OnAmxxAttach
+// AMXX detach
+#define FN_AMXX_DETACH OnAmxxDetach
+// All plugins loaded
+//   Do forward functions init here (MF_RegisterForward)
+// #define FN_AMXX_PLUGINSLOADED OnPluginsLoaded
+
+/**** METAMOD ****/
+// If your module doesn't use metamod, you may close the file now :)
+#ifdef USE_METAMOD
+// ----
+// Hook Functions
+// Uncomment these to be called
+// You can also change the function name
+
+// - Metamod init functions
+// Also consider using FN_AMXX_*
+// Meta query
+//#define FN_META_QUERY OnMetaQuery
+// Meta attach
+//#define FN_META_ATTACH OnMetaAttach
+// Meta detach
+//#define FN_META_DETACH OnMetaDetach
+
+// (wd) are Will Day's notes
+// - GetEntityAPI2 functions
+// #define FN_GameDLLInit				GameDLLInit					/* pfnGameInit() */
+// #define FN_DispatchSpawn				DispatchSpawn				/* pfnSpawn() */
+// #define FN_DispatchThink				DispatchThink				/* pfnThink() */
+// #define FN_DispatchUse				DispatchUse					/* pfnUse() */
+// #define FN_DispatchTouch				DispatchTouch				/* pfnTouch() */
+// #define FN_DispatchBlocked			DispatchBlocked				/* pfnBlocked() */
+// #define FN_DispatchKeyValue			DispatchKeyValue			/* pfnKeyValue() */
+// #define FN_DispatchSave				DispatchSave				/* pfnSave() */
+// #define FN_DispatchRestore			DispatchRestore				/* pfnRestore() */
+// #define FN_DispatchObjectCollsionBox	DispatchObjectCollsionBox	/* pfnSetAbsBox() */
+// #define FN_SaveWriteFields			SaveWriteFields				/* pfnSaveWriteFields() */
+// #define FN_SaveReadFields			SaveReadFields				/* pfnSaveReadFields() */
+// #define FN_SaveGlobalState			SaveGlobalState				/* pfnSaveGlobalState() */
+// #define FN_RestoreGlobalState		RestoreGlobalState			/* pfnRestoreGlobalState() */
+// #define FN_ResetGlobalState			ResetGlobalState			/* pfnResetGlobalState() */
+// #define FN_ClientConnect				ClientConnect				/* pfnClientConnect()			(wd) Client has connected */
+// #define FN_ClientDisconnect			ClientDisconnect			/* pfnClientDisconnect()		(wd) Player has left the game */
+// #define FN_ClientKill				ClientKill					/* pfnClientKill()				(wd) Player has typed "kill" */
+// #define FN_ClientPutInServer			ClientPutInServer			/* pfnClientPutInServer()		(wd) Client is entering the game */
+// #define FN_ClientCommand				ClientCommand				/* pfnClientCommand()			(wd) Player has sent a command (typed or from a bind) */
+// #define FN_ClientUserInfoChanged		ClientUserInfoChanged		/* pfnClientUserInfoChanged()	(wd) Client has updated their setinfo structure */
+// #define FN_ServerActivate			ServerActivate				/* pfnServerActivate()			(wd) Server is starting a new map */
+// #define FN_ServerDeactivate			ServerDeactivate			/* pfnServerDeactivate()		(wd) Server is leaving the map (shutdown or changelevel); SDK2 */
+// #define FN_PlayerPreThink			PlayerPreThink				/* pfnPlayerPreThink() */
+// #define FN_PlayerPostThink			PlayerPostThink				/* pfnPlayerPostThink() */
+// #define FN_StartFrame				StartFrame					/* pfnStartFrame() */
+// #define FN_ParmsNewLevel				ParmsNewLevel				/* pfnParmsNewLevel() */
+// #define FN_ParmsChangeLevel			ParmsChangeLevel			/* pfnParmsChangeLevel() */
+// #define FN_GetGameDescription		GetGameDescription			/* pfnGetGameDescription()		Returns string describing current .dll.  E.g. "TeamFotrress 2" "Half-Life" */
+// #define FN_PlayerCustomization		PlayerCustomization			/* pfnPlayerCustomization()	Notifies .dll of new customization for player. */
+// #define FN_SpectatorConnect			SpectatorConnect			/* pfnSpectatorConnect()		Called when spectator joins server */
+// #define FN_SpectatorDisconnect		SpectatorDisconnect			/* pfnSpectatorDisconnect()	Called when spectator leaves the server */
+// #define FN_SpectatorThink			SpectatorThink				/* pfnSpectatorThink()			Called when spectator sends a command packet (usercmd_t) */
+// #define FN_Sys_Error					Sys_Error					/* pfnSys_Error()				Notify game .dll that engine is going to shut down.  Allows mod authors to set a breakpoint.  SDK2 */
+// #define FN_PM_Move					PM_Move						/* pfnPM_Move()				(wd) SDK2 */
+// #define FN_PM_Init					PM_Init						/* pfnPM_Init()				Server version of player movement initialization; (wd) SDK2 */
+// #define FN_PM_FindTextureType		PM_FindTextureType			/* pfnPM_FindTextureType()		(wd) SDK2 */
+// #define FN_SetupVisibility			SetupVisibility				/* pfnSetupVisibility()		Set up PVS and PAS for networking for this client; (wd) SDK2 */
+// #define FN_UpdateClientData			UpdateClientData			/* pfnUpdateClientData()		Set up data sent only to specific client; (wd) SDK2 */
+// #define FN_AddToFullPack				AddToFullPack				/* pfnAddToFullPack()			(wd) SDK2 */
+// #define FN_CreateBaseline			CreateBaseline				/* pfnCreateBaseline()			Tweak entity baseline for network encoding allows setup of player baselines too.; (wd) SDK2 */
+// #define FN_RegisterEncoders			RegisterEncoders			/* pfnRegisterEncoders()		Callbacks for network encoding; (wd) SDK2 */
+// #define FN_GetWeaponData				GetWeaponData				/* pfnGetWeaponData()			(wd) SDK2 */
+// #define FN_CmdStart					CmdStart					/* pfnCmdStart()				(wd) SDK2 */
+// #define FN_CmdEnd					CmdEnd						/* pfnCmdEnd()					(wd) SDK2 */
+// #define FN_ConnectionlessPacket		ConnectionlessPacket		/* pfnConnectionlessPacket()	(wd) SDK2 */
+// #define FN_GetHullBounds				GetHullBounds				/* pfnGetHullBounds()			(wd) SDK2 */
+// #define FN_CreateInstancedBaselines	CreateInstancedBaselines	/* pfnCreateInstancedBaselines()	(wd) SDK2 */
+// #define FN_InconsistentFile			InconsistentFile			/* pfnInconsistentFile()		(wd) SDK2 */
+// #define FN_AllowLagCompensation		AllowLagCompensation		/* pfnAllowLagCompensation()	(wd) SDK2 */
+
+// - GetEntityAPI2_Post functions
+// #define FN_GameDLLInit_Post					GameDLLInit_Post
+// #define FN_DispatchSpawn_Post				DispatchSpawn_Post
+// #define FN_DispatchThink_Post				DispatchThink_Post
+// #define FN_DispatchUse_Post					DispatchUse_Post
+// #define FN_DispatchTouch_Post				DispatchTouch_Post
+// #define FN_DispatchBlocked_Post				DispatchBlocked_Post
+// #define FN_DispatchKeyValue_Post				DispatchKeyValue_Post
+// #define FN_DispatchSave_Post					DispatchSave_Post
+// #define FN_DispatchRestore_Post				DispatchRestore_Post
+// #define FN_DispatchObjectCollsionBox_Post	DispatchObjectCollsionBox_Post
+// #define FN_SaveWriteFields_Post				SaveWriteFields_Post
+// #define FN_SaveReadFields_Post				SaveReadFields_Post
+// #define FN_SaveGlobalState_Post				SaveGlobalState_Post
+// #define FN_RestoreGlobalState_Post			RestoreGlobalState_Post
+// #define FN_ResetGlobalState_Post				ResetGlobalState_Post
+// #define FN_ClientConnect_Post				ClientConnect_Post
+// #define FN_ClientDisconnect_Post				ClientDisconnect_Post
+// #define FN_ClientKill_Post					ClientKill_Post
+// #define FN_ClientPutInServer_Post			ClientPutInServer_Post
+// #define FN_ClientCommand_Post				ClientCommand_Post
+// #define FN_ClientUserInfoChanged_Post		ClientUserInfoChanged_Post
+// #define FN_ServerActivate_Post				ServerActivate_Post
+// #define FN_ServerDeactivate_Post				ServerDeactivate_Post
+// #define FN_PlayerPreThink_Post				PlayerPreThink_Post
+// #define FN_PlayerPostThink_Post				PlayerPostThink_Post
+// #define FN_StartFrame_Post					StartFrame_Post
+// #define FN_ParmsNewLevel_Post				ParmsNewLevel_Post
+// #define FN_ParmsChangeLevel_Post				ParmsChangeLevel_Post
+// #define FN_GetGameDescription_Post			GetGameDescription_Post
+// #define FN_PlayerCustomization_Post			PlayerCustomization_Post
+// #define FN_SpectatorConnect_Post				SpectatorConnect_Post
+// #define FN_SpectatorDisconnect_Post			SpectatorDisconnect_Post
+// #define FN_SpectatorThink_Post				SpectatorThink_Post
+// #define FN_Sys_Error_Post					Sys_Error_Post
+// #define FN_PM_Move_Post						PM_Move_Post
+// #define FN_PM_Init_Post						PM_Init_Post
+// #define FN_PM_FindTextureType_Post			PM_FindTextureType_Post
+// #define FN_SetupVisibility_Post				SetupVisibility_Post
+// #define FN_UpdateClientData_Post				UpdateClientData_Post
+// #define FN_AddToFullPack_Post				AddToFullPack_Post
+// #define FN_CreateBaseline_Post				CreateBaseline_Post
+// #define FN_RegisterEncoders_Post				RegisterEncoders_Post
+// #define FN_GetWeaponData_Post				GetWeaponData_Post
+// #define FN_CmdStart_Post						CmdStart_Post
+// #define FN_CmdEnd_Post						CmdEnd_Post
+// #define FN_ConnectionlessPacket_Post			ConnectionlessPacket_Post
+// #define FN_GetHullBounds_Post				GetHullBounds_Post
+// #define FN_CreateInstancedBaselines_Post		CreateInstancedBaselines_Post
+// #define FN_InconsistentFile_Post				InconsistentFile_Post
+// #define FN_AllowLagCompensation_Post			AllowLagCompensation_Post
+
+// - GetEngineAPI functions
+// #define FN_PrecacheModel						PrecacheModel
+// #define FN_PrecacheSound						PrecacheSound
+// #define FN_SetModel							SetModel
+// #define FN_ModelIndex						ModelIndex
+// #define FN_ModelFrames						ModelFrames
+// #define FN_SetSize							SetSize
+// #define FN_ChangeLevel						ChangeLevel
+// #define FN_GetSpawnParms						GetSpawnParms
+// #define FN_SaveSpawnParms					SaveSpawnParms
+// #define FN_VecToYaw							VecToYaw
+// #define FN_VecToAngles						VecToAngles
+// #define FN_MoveToOrigin						MoveToOrigin
+// #define FN_ChangeYaw							ChangeYaw
+// #define FN_ChangePitch						ChangePitch
+// #define FN_FindEntityByString				FindEntityByString
+// #define FN_GetEntityIllum					GetEntityIllum
+// #define FN_FindEntityInSphere				FindEntityInSphere
+// #define FN_FindClientInPVS					FindClientInPVS
+// #define FN_EntitiesInPVS						EntitiesInPVS
+// #define FN_MakeVectors						MakeVectors
+// #define FN_AngleVectors						AngleVectors
+// #define FN_CreateEntity						CreateEntity
+// #define FN_RemoveEntity						RemoveEntity
+// #define FN_CreateNamedEntity					CreateNamedEntity
+// #define FN_MakeStatic						MakeStatic
+// #define FN_EntIsOnFloor						EntIsOnFloor
+// #define FN_DropToFloor						DropToFloor
+// #define FN_WalkMove							WalkMove
+// #define FN_SetOrigin							SetOrigin
+// #define FN_EmitSound							EmitSound
+// #define FN_EmitAmbientSound					EmitAmbientSound
+// #define FN_TraceLine							TraceLine
+// #define FN_TraceToss							TraceToss
+// #define FN_TraceMonsterHull					TraceMonsterHull
+// #define FN_TraceHull							TraceHull
+// #define FN_TraceModel						TraceModel
+// #define FN_TraceTexture						TraceTexture
+// #define FN_TraceSphere						TraceSphere
+// #define FN_GetAimVector						GetAimVector
+// #define FN_ServerCommand						ServerCommand
+// #define FN_ServerExecute						ServerExecute
+// #define FN_engClientCommand					engClientCommand
+// #define FN_ParticleEffect					ParticleEffect
+// #define FN_LightStyle						LightStyle
+// #define FN_DecalIndex						DecalIndex
+// #define FN_PointContents						PointContents
+// #define FN_MessageBegin						MessageBegin
+// #define FN_MessageEnd						MessageEnd
+// #define FN_WriteByte							WriteByte
+// #define FN_WriteChar							WriteChar
+// #define FN_WriteShort						WriteShort
+// #define FN_WriteLong							WriteLong
+// #define FN_WriteAngle						WriteAngle
+// #define FN_WriteCoord						WriteCoord
+// #define FN_WriteString						WriteString
+// #define FN_WriteEntity						WriteEntity
+// #define FN_CVarRegister						CVarRegister
+// #define FN_CVarGetFloat						CVarGetFloat
+// #define FN_CVarGetString						CVarGetString
+// #define FN_CVarSetFloat						CVarSetFloat
+// #define FN_CVarSetString						CVarSetString
+// #define FN_AlertMessage						AlertMessage
+// #define FN_EngineFprintf						EngineFprintf
+// #define FN_PvAllocEntPrivateData				PvAllocEntPrivateData
+// #define FN_PvEntPrivateData					PvEntPrivateData
+// #define FN_FreeEntPrivateData				FreeEntPrivateData
+// #define FN_SzFromIndex						SzFromIndex
+// #define FN_AllocString						AllocString
+// #define FN_GetVarsOfEnt						GetVarsOfEnt
+// #define FN_PEntityOfEntOffset				PEntityOfEntOffset
+// #define FN_EntOffsetOfPEntity				EntOffsetOfPEntity
+// #define FN_IndexOfEdict						IndexOfEdict
+// #define FN_PEntityOfEntIndex					PEntityOfEntIndex
+// #define FN_FindEntityByVars					FindEntityByVars
+// #define FN_GetModelPtr						GetModelPtr
+// #define FN_RegUserMsg						RegUserMsg
+// #define FN_AnimationAutomove					AnimationAutomove
+// #define FN_GetBonePosition					GetBonePosition
+// #define FN_FunctionFromName					FunctionFromName
+// #define FN_NameForFunction					NameForFunction
+// #define FN_ClientPrintf						ClientPrintf
+// #define FN_ServerPrint						ServerPrint
+// #define FN_Cmd_Args							Cmd_Args
+// #define FN_Cmd_Argv							Cmd_Argv
+// #define FN_Cmd_Argc							Cmd_Argc
+// #define FN_GetAttachment						GetAttachment
+// #define FN_CRC32_Init						CRC32_Init
+// #define FN_CRC32_ProcessBuffer				CRC32_ProcessBuffer
+// #define FN_CRC32_ProcessByte					CRC32_ProcessByte
+// #define FN_CRC32_Final						CRC32_Final
+// #define FN_RandomLong						RandomLong
+// #define FN_RandomFloat						RandomFloat
+// #define FN_SetView							SetView
+// #define FN_Time								Time
+// #define FN_CrosshairAngle					CrosshairAngle
+// #define FN_LoadFileForMe						LoadFileForMe
+// #define FN_FreeFile							FreeFile
+// #define FN_EndSection						EndSection
+// #define FN_CompareFileTime					CompareFileTime
+// #define FN_GetGameDir						GetGameDir
+// #define FN_Cvar_RegisterVariable				Cvar_RegisterVariable
+// #define FN_FadeClientVolume					FadeClientVolume
+// #define FN_SetClientMaxspeed					SetClientMaxspeed
+// #define FN_CreateFakeClient					CreateFakeClient
+// #define FN_RunPlayerMove						RunPlayerMove
+// #define FN_NumberOfEntities					NumberOfEntities
+// #define FN_GetInfoKeyBuffer					GetInfoKeyBuffer
+// #define FN_InfoKeyValue						InfoKeyValue
+// #define FN_SetKeyValue						SetKeyValue
+// #define FN_SetClientKeyValue					SetClientKeyValue
+// #define FN_IsMapValid						IsMapValid
+// #define FN_StaticDecal						StaticDecal
+// #define FN_PrecacheGeneric					PrecacheGeneric
+// #define FN_GetPlayerUserId					GetPlayerUserId
+// #define FN_BuildSoundMsg						BuildSoundMsg
+// #define FN_IsDedicatedServer					IsDedicatedServer
+// #define FN_CVarGetPointer					CVarGetPointer
+// #define FN_GetPlayerWONId					GetPlayerWONId
+// #define FN_Info_RemoveKey					Info_RemoveKey
+// #define FN_GetPhysicsKeyValue				GetPhysicsKeyValue
+// #define FN_SetPhysicsKeyValue				SetPhysicsKeyValue
+// #define FN_GetPhysicsInfoString				GetPhysicsInfoString
+// #define FN_PrecacheEvent						PrecacheEvent
+// #define FN_PlaybackEvent						PlaybackEvent
+// #define FN_SetFatPVS							SetFatPVS
+// #define FN_SetFatPAS							SetFatPAS
+// #define FN_CheckVisibility					CheckVisibility
+// #define FN_DeltaSetField						DeltaSetField
+// #define FN_DeltaUnsetField					DeltaUnsetField
+// #define FN_DeltaAddEncoder					DeltaAddEncoder
+// #define FN_GetCurrentPlayer					GetCurrentPlayer
+// #define FN_CanSkipPlayer						CanSkipPlayer
+// #define FN_DeltaFindField					DeltaFindField
+// #define FN_DeltaSetFieldByIndex				DeltaSetFieldByIndex
+// #define FN_DeltaUnsetFieldByIndex			DeltaUnsetFieldByIndex
+// #define FN_SetGroupMask						SetGroupMask
+// #define FN_engCreateInstancedBaseline		engCreateInstancedBaseline
+// #define FN_Cvar_DirectSet					Cvar_DirectSet
+// #define FN_ForceUnmodified					ForceUnmodified
+// #define FN_GetPlayerStats					GetPlayerStats
+// #define FN_AddServerCommand					AddServerCommand
+// #define FN_Voice_GetClientListening			Voice_GetClientListening
+// #define FN_Voice_SetClientListening			Voice_SetClientListening
+// #define FN_GetPlayerAuthId					GetPlayerAuthId
+
+// - GetEngineAPI_Post functions
+// #define FN_PrecacheModel_Post				PrecacheModel_Post
+// #define FN_PrecacheSound_Post				PrecacheSound_Post
+// #define FN_SetModel_Post						SetModel_Post
+// #define FN_ModelIndex_Post					ModelIndex_Post
+// #define FN_ModelFrames_Post					ModelFrames_Post
+// #define FN_SetSize_Post						SetSize_Post
+// #define FN_ChangeLevel_Post					ChangeLevel_Post
+// #define FN_GetSpawnParms_Post				GetSpawnParms_Post
+// #define FN_SaveSpawnParms_Post				SaveSpawnParms_Post
+// #define FN_VecToYaw_Post						VecToYaw_Post
+// #define FN_VecToAngles_Post					VecToAngles_Post
+// #define FN_MoveToOrigin_Post					MoveToOrigin_Post
+// #define FN_ChangeYaw_Post					ChangeYaw_Post
+// #define FN_ChangePitch_Post					ChangePitch_Post
+// #define FN_FindEntityByString_Post			FindEntityByString_Post
+// #define FN_GetEntityIllum_Post				GetEntityIllum_Post
+// #define FN_FindEntityInSphere_Post			FindEntityInSphere_Post
+// #define FN_FindClientInPVS_Post				FindClientInPVS_Post
+// #define FN_EntitiesInPVS_Post				EntitiesInPVS_Post
+// #define FN_MakeVectors_Post					MakeVectors_Post
+// #define FN_AngleVectors_Post					AngleVectors_Post
+// #define FN_CreateEntity_Post					CreateEntity_Post
+// #define FN_RemoveEntity_Post					RemoveEntity_Post
+// #define FN_CreateNamedEntity_Post			CreateNamedEntity_Post
+// #define FN_MakeStatic_Post					MakeStatic_Post
+// #define FN_EntIsOnFloor_Post					EntIsOnFloor_Post
+// #define FN_DropToFloor_Post					DropToFloor_Post
+// #define FN_WalkMove_Post						WalkMove_Post
+// #define FN_SetOrigin_Post					SetOrigin_Post
+// #define FN_EmitSound_Post					EmitSound_Post
+// #define FN_EmitAmbientSound_Post				EmitAmbientSound_Post
+// #define FN_TraceLine_Post					TraceLine_Post
+// #define FN_TraceToss_Post					TraceToss_Post
+// #define FN_TraceMonsterHull_Post				TraceMonsterHull_Post
+// #define FN_TraceHull_Post					TraceHull_Post
+// #define FN_TraceModel_Post					TraceModel_Post
+// #define FN_TraceTexture_Post					TraceTexture_Post
+// #define FN_TraceSphere_Post					TraceSphere_Post
+// #define FN_GetAimVector_Post					GetAimVector_Post
+// #define FN_ServerCommand_Post				ServerCommand_Post
+// #define FN_ServerExecute_Post				ServerExecute_Post
+// #define FN_engClientCommand_Post				engClientCommand_Post
+// #define FN_ParticleEffect_Post				ParticleEffect_Post
+// #define FN_LightStyle_Post					LightStyle_Post
+// #define FN_DecalIndex_Post					DecalIndex_Post
+// #define FN_PointContents_Post				PointContents_Post
+// #define FN_MessageBegin_Post					MessageBegin_Post
+// #define FN_MessageEnd_Post					MessageEnd_Post
+// #define FN_WriteByte_Post					WriteByte_Post
+// #define FN_WriteChar_Post					WriteChar_Post
+// #define FN_WriteShort_Post					WriteShort_Post
+// #define FN_WriteLong_Post					WriteLong_Post
+// #define FN_WriteAngle_Post					WriteAngle_Post
+// #define FN_WriteCoord_Post					WriteCoord_Post
+// #define FN_WriteString_Post					WriteString_Post
+// #define FN_WriteEntity_Post					WriteEntity_Post
+// #define FN_CVarRegister_Post					CVarRegister_Post
+// #define FN_CVarGetFloat_Post					CVarGetFloat_Post
+// #define FN_CVarGetString_Post				CVarGetString_Post
+// #define FN_CVarSetFloat_Post					CVarSetFloat_Post
+// #define FN_CVarSetString_Post				CVarSetString_Post
+// #define FN_AlertMessage_Post					AlertMessage_Post
+// #define FN_EngineFprintf_Post				EngineFprintf_Post
+// #define FN_PvAllocEntPrivateData_Post		PvAllocEntPrivateData_Post
+// #define FN_PvEntPrivateData_Post				PvEntPrivateData_Post
+// #define FN_FreeEntPrivateData_Post			FreeEntPrivateData_Post
+// #define FN_SzFromIndex_Post					SzFromIndex_Post
+// #define FN_AllocString_Post					AllocString_Post
+// #define FN_GetVarsOfEnt_Post					GetVarsOfEnt_Post
+// #define FN_PEntityOfEntOffset_Post			PEntityOfEntOffset_Post
+// #define FN_EntOffsetOfPEntity_Post			EntOffsetOfPEntity_Post
+// #define FN_IndexOfEdict_Post					IndexOfEdict_Post
+// #define FN_PEntityOfEntIndex_Post			PEntityOfEntIndex_Post
+// #define FN_FindEntityByVars_Post				FindEntityByVars_Post
+// #define FN_GetModelPtr_Post					GetModelPtr_Post
+// #define FN_RegUserMsg_Post					RegUserMsg_Post
+// #define FN_AnimationAutomove_Post			AnimationAutomove_Post
+// #define FN_GetBonePosition_Post				GetBonePosition_Post
+// #define FN_FunctionFromName_Post				FunctionFromName_Post
+// #define FN_NameForFunction_Post				NameForFunction_Post
+// #define FN_ClientPrintf_Post					ClientPrintf_Post
+// #define FN_ServerPrint_Post					ServerPrint_Post
+// #define FN_Cmd_Args_Post						Cmd_Args_Post
+// #define FN_Cmd_Argv_Post						Cmd_Argv_Post
+// #define FN_Cmd_Argc_Post						Cmd_Argc_Post
+// #define FN_GetAttachment_Post				GetAttachment_Post
+// #define FN_CRC32_Init_Post					CRC32_Init_Post
+// #define FN_CRC32_ProcessBuffer_Post			CRC32_ProcessBuffer_Post
+// #define FN_CRC32_ProcessByte_Post			CRC32_ProcessByte_Post
+// #define FN_CRC32_Final_Post					CRC32_Final_Post
+// #define FN_RandomLong_Post					RandomLong_Post
+// #define FN_RandomFloat_Post					RandomFloat_Post
+// #define FN_SetView_Post						SetView_Post
+// #define FN_Time_Post							Time_Post
+// #define FN_CrosshairAngle_Post				CrosshairAngle_Post
+// #define FN_LoadFileForMe_Post				LoadFileForMe_Post
+// #define FN_FreeFile_Post						FreeFile_Post
+// #define FN_EndSection_Post					EndSection_Post
+// #define FN_CompareFileTime_Post				CompareFileTime_Post
+// #define FN_GetGameDir_Post					GetGameDir_Post
+// #define FN_Cvar_RegisterVariable_Post		Cvar_RegisterVariable_Post
+// #define FN_FadeClientVolume_Post				FadeClientVolume_Post
+// #define FN_SetClientMaxspeed_Post			SetClientMaxspeed_Post
+// #define FN_CreateFakeClient_Post				CreateFakeClient_Post
+// #define FN_RunPlayerMove_Post				RunPlayerMove_Post
+// #define FN_NumberOfEntities_Post				NumberOfEntities_Post
+// #define FN_GetInfoKeyBuffer_Post				GetInfoKeyBuffer_Post
+// #define FN_InfoKeyValue_Post					InfoKeyValue_Post
+// #define FN_SetKeyValue_Post					SetKeyValue_Post
+// #define FN_SetClientKeyValue_Post			SetClientKeyValue_Post
+// #define FN_IsMapValid_Post					IsMapValid_Post
+// #define FN_StaticDecal_Post					StaticDecal_Post
+// #define FN_PrecacheGeneric_Post				PrecacheGeneric_Post
+// #define FN_GetPlayerUserId_Post				GetPlayerUserId_Post
+// #define FN_BuildSoundMsg_Post				BuildSoundMsg_Post
+// #define FN_IsDedicatedServer_Post			IsDedicatedServer_Post
+// #define FN_CVarGetPointer_Post				CVarGetPointer_Post
+// #define FN_GetPlayerWONId_Post				GetPlayerWONId_Post
+// #define FN_Info_RemoveKey_Post				Info_RemoveKey_Post
+// #define FN_GetPhysicsKeyValue_Post			GetPhysicsKeyValue_Post
+// #define FN_SetPhysicsKeyValue_Post			SetPhysicsKeyValue_Post
+// #define FN_GetPhysicsInfoString_Post			GetPhysicsInfoString_Post
+// #define FN_PrecacheEvent_Post				PrecacheEvent_Post
+// #define FN_PlaybackEvent_Post				PlaybackEvent_Post
+// #define FN_SetFatPVS_Post					SetFatPVS_Post
+// #define FN_SetFatPAS_Post					SetFatPAS_Post
+// #define FN_CheckVisibility_Post				CheckVisibility_Post
+// #define FN_DeltaSetField_Post				DeltaSetField_Post
+// #define FN_DeltaUnsetField_Post				DeltaUnsetField_Post
+// #define FN_DeltaAddEncoder_Post				DeltaAddEncoder_Post
+// #define FN_GetCurrentPlayer_Post				GetCurrentPlayer_Post
+// #define FN_CanSkipPlayer_Post				CanSkipPlayer_Post
+// #define FN_DeltaFindField_Post				DeltaFindField_Post
+// #define FN_DeltaSetFieldByIndex_Post			DeltaSetFieldByIndex_Post
+// #define FN_DeltaUnsetFieldByIndex_Post		DeltaUnsetFieldByIndex_Post
+// #define FN_SetGroupMask_Post					SetGroupMask_Post
+// #define FN_engCreateInstancedBaseline_Post	engCreateInstancedBaseline_Post
+// #define FN_Cvar_DirectSet_Post				Cvar_DirectSet_Post
+// #define FN_ForceUnmodified_Post				ForceUnmodified_Post
+// #define FN_GetPlayerStats_Post				GetPlayerStats_Post
+// #define FN_AddServerCommand_Post				AddServerCommand_Post
+// #define FN_Voice_GetClientListening_Post		Voice_GetClientListening_Post
+// #define FN_Voice_SetClientListening_Post		Voice_SetClientListening_Post
+// #define FN_GetPlayerAuthId_Post				GetPlayerAuthId_Post
+
+// #define FN_OnFreeEntPrivateData				OnFreeEntPrivateData				
+// #define FN_GameShutdown						GameShutdown
+// #define FN_ShouldCollide						ShouldCollide
+
+// #define FN_OnFreeEntPrivateData_Post			OnFreeEntPrivateData_Post
+// #define FN_GameShutdown_Post					GameShutdown_Post
+// #define FN_ShouldCollide_Post				ShouldCollide_Post
+
+
+#endif // USE_METAMOD
+
+#endif // __MODULECONFIG_H__
\ No newline at end of file
diff --git a/dlls/regex/pcre.h b/dlls/regex/pcre.h
new file mode 100755
index 00000000..c8a02754
--- /dev/null
+++ b/dlls/regex/pcre.h
@@ -0,0 +1,193 @@
+/*************************************************
+*       Perl-Compatible Regular Expressions      *
+*************************************************/
+
+/* Copyright (c) 1997-2003 University of Cambridge */
+
+#ifndef _PCRE_H
+#define _PCRE_H
+
+/* The file pcre.h is build by "configure". Do not edit it; instead
+make changes to pcre.in. */
+
+#define PCRE_MAJOR          4
+#define PCRE_MINOR          5
+#define PCRE_DATE           01-December-2003
+
+/* Win32 uses DLL by default */
+
+#ifdef _WIN32
+#  ifdef PCRE_DEFINITION
+#    ifdef DLL_EXPORT
+#      define PCRE_DATA_SCOPE __declspec(dllexport)
+#    endif
+#  else
+#    ifndef PCRE_STATIC
+#      define PCRE_DATA_SCOPE extern __declspec(dllimport)
+#    endif
+#  endif
+#endif
+#ifndef PCRE_DATA_SCOPE
+#  define PCRE_DATA_SCOPE     extern
+#endif
+
+/* Have to include stdlib.h in order to ensure that size_t is defined;
+it is needed here for malloc. */
+
+#include <stdlib.h>
+
+/* Allow for C++ users */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Options */
+
+#define PCRE_CASELESS           0x0001
+#define PCRE_MULTILINE          0x0002
+#define PCRE_DOTALL             0x0004
+#define PCRE_EXTENDED           0x0008
+#define PCRE_ANCHORED           0x0010
+#define PCRE_DOLLAR_ENDONLY     0x0020
+#define PCRE_EXTRA              0x0040
+#define PCRE_NOTBOL             0x0080
+#define PCRE_NOTEOL             0x0100
+#define PCRE_UNGREEDY           0x0200
+#define PCRE_NOTEMPTY           0x0400
+#define PCRE_UTF8               0x0800
+#define PCRE_NO_AUTO_CAPTURE    0x1000
+#define PCRE_NO_UTF8_CHECK      0x2000
+
+/* Exec-time and get/set-time error codes */
+
+#define PCRE_ERROR_NOMATCH         (-1)
+#define PCRE_ERROR_NULL            (-2)
+#define PCRE_ERROR_BADOPTION       (-3)
+#define PCRE_ERROR_BADMAGIC        (-4)
+#define PCRE_ERROR_UNKNOWN_NODE    (-5)
+#define PCRE_ERROR_NOMEMORY        (-6)
+#define PCRE_ERROR_NOSUBSTRING     (-7)
+#define PCRE_ERROR_MATCHLIMIT      (-8)
+#define PCRE_ERROR_CALLOUT         (-9)  /* Never used by PCRE itself */
+#define PCRE_ERROR_BADUTF8        (-10)
+#define PCRE_ERROR_BADUTF8_OFFSET (-11)
+
+/* Request types for pcre_fullinfo() */
+
+#define PCRE_INFO_OPTIONS            0
+#define PCRE_INFO_SIZE               1
+#define PCRE_INFO_CAPTURECOUNT       2
+#define PCRE_INFO_BACKREFMAX         3
+#define PCRE_INFO_FIRSTBYTE          4
+#define PCRE_INFO_FIRSTCHAR          4  /* For backwards compatibility */
+#define PCRE_INFO_FIRSTTABLE         5
+#define PCRE_INFO_LASTLITERAL        6
+#define PCRE_INFO_NAMEENTRYSIZE      7
+#define PCRE_INFO_NAMECOUNT          8
+#define PCRE_INFO_NAMETABLE          9
+#define PCRE_INFO_STUDYSIZE         10
+
+/* Request types for pcre_config() */
+
+#define PCRE_CONFIG_UTF8                    0
+#define PCRE_CONFIG_NEWLINE                 1
+#define PCRE_CONFIG_LINK_SIZE               2
+#define PCRE_CONFIG_POSIX_MALLOC_THRESHOLD  3
+#define PCRE_CONFIG_MATCH_LIMIT             4
+#define PCRE_CONFIG_STACKRECURSE            5
+
+/* Bit flags for the pcre_extra structure */
+
+#define PCRE_EXTRA_STUDY_DATA          0x0001
+#define PCRE_EXTRA_MATCH_LIMIT         0x0002
+#define PCRE_EXTRA_CALLOUT_DATA        0x0004
+
+/* Types */
+
+struct real_pcre;                 /* declaration; the definition is private  */
+typedef struct real_pcre pcre;
+
+/* The structure for passing additional data to pcre_exec(). This is defined in
+such as way as to be extensible. */
+
+typedef struct pcre_extra {
+  unsigned long int flags;        /* Bits for which fields are set */
+  void *study_data;               /* Opaque data from pcre_study() */
+  unsigned long int match_limit;  /* Maximum number of calls to match() */
+  void *callout_data;             /* Data passed back in callouts */
+} pcre_extra;
+
+/* The structure for passing out data via the pcre_callout_function. We use a
+structure so that new fields can be added on the end in future versions,
+without changing the API of the function, thereby allowing old clients to work
+without modification. */
+
+typedef struct pcre_callout_block {
+  int          version;           /* Identifies version of block */
+  /* ------------------------ Version 0 ------------------------------- */
+  int          callout_number;    /* Number compiled into pattern */
+  int         *offset_vector;     /* The offset vector */
+  const char  *subject;           /* The subject being matched */
+  int          subject_length;    /* The length of the subject */
+  int          start_match;       /* Offset to start of this match attempt */
+  int          current_position;  /* Where we currently are */
+  int          capture_top;       /* Max current capture */
+  int          capture_last;      /* Most recently closed capture */
+  void        *callout_data;      /* Data passed in with the call */
+  /* ------------------------------------------------------------------ */
+} pcre_callout_block;
+
+/* Indirection for store get and free functions. These can be set to
+alternative malloc/free functions if required. Special ones are used in the
+non-recursive case for "frames". There is also an optional callout function
+that is triggered by the (?) regex item. Some magic is required for Win32 DLL;
+it is null on other OS. For Virtual Pascal, these have to be different again.
+*/
+
+#ifndef VPCOMPAT
+PCRE_DATA_SCOPE void *(*pcre_malloc)(size_t);
+PCRE_DATA_SCOPE void  (*pcre_free)(void *);
+PCRE_DATA_SCOPE void *(*pcre_stack_malloc)(size_t);
+PCRE_DATA_SCOPE void  (*pcre_stack_free)(void *);
+PCRE_DATA_SCOPE int   (*pcre_callout)(pcre_callout_block *);
+#else   /* VPCOMPAT */
+extern void *pcre_malloc(size_t);
+extern void  pcre_free(void *);
+extern void *pcre_stack_malloc(size_t);
+extern void  pcre_stack_free(void *);
+extern int   pcre_callout(pcre_callout_block *);
+#endif  /* VPCOMPAT */
+
+/* Exported PCRE functions */
+
+extern pcre *pcre_compile(const char *, int, const char **,
+              int *, const unsigned char *);
+extern int  pcre_config(int, void *);
+extern int  pcre_copy_named_substring(const pcre *, const char *,
+              int *, int, const char *, char *, int);
+extern int  pcre_copy_substring(const char *, int *, int, int,
+              char *, int);
+extern int  pcre_exec(const pcre *, const pcre_extra *,
+              const char *, int, int, int, int *, int);
+extern void pcre_free_substring(const char *);
+extern void pcre_free_substring_list(const char **);
+extern int  pcre_fullinfo(const pcre *, const pcre_extra *, int,
+              void *);
+extern int  pcre_get_named_substring(const pcre *, const char *,
+              int *, int,  const char *, const char **);
+extern int  pcre_get_stringnumber(const pcre *, const char *);
+extern int  pcre_get_substring(const char *, int *, int, int,
+              const char **);
+extern int  pcre_get_substring_list(const char *, int *, int,
+              const char ***);
+extern int  pcre_info(const pcre *, int *, int *);
+extern const unsigned char *pcre_maketables(void);
+extern pcre_extra *pcre_study(const pcre *, int, const char **);
+extern const char *pcre_version(void);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif /* End of pcre.h */