diff --git a/dlls/hamsandwich/CString.h b/dlls/hamsandwich/CString.h
new file mode 100644
index 00000000..1c77cfac
--- /dev/null
+++ b/dlls/hamsandwich/CString.h
@@ -0,0 +1,413 @@
+/* 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 _INCLUDE_CSTRING_H
+#define _INCLUDE_CSTRING_H
+
+#include <string.h>
+#include <stdio.h>
+
+//by David "BAILOPAN" Anderson
+class String
+{
+public:
+	String() 
+	{
+		v = NULL;
+		a_size = 0;
+		//assign("");
+	}
+
+	~String()
+	{ 
+		if (v) 
+			delete [] v; 
+	}
+
+	String(const char *src) 
+	{
+		v = NULL; 
+		a_size = 0;
+		assign(src); 
+	}
+
+	const char * _fread(FILE *fp) 	 
+	{ 	 
+		Grow(512, false); 	 
+		char *ret = fgets(v, 511, fp); 	 
+		return ret; 	 
+	}
+
+	String(const String &src) 
+	{
+		v = NULL;
+		a_size = 0;
+		assign(src.c_str()); 
+	}
+
+	const char *c_str() { return v?v:""; }
+
+	const char *c_str() const { return v?v:""; }
+
+	void append(const char *t)
+	{
+		Grow(size() + strlen(t) + 1);
+		strcat(v, t);
+	}
+
+	void append(const char c)
+	{
+		size_t len = size();
+		Grow(len + 2);
+		v[len] = c;
+		v[len + 1] = '\0';
+	}
+
+	void append(String &d)
+	{
+		append(d.c_str());
+	}
+
+	void assign(const String &src)
+	{
+		assign(src.c_str());
+	}
+
+	void assign(const char *d)
+	{
+		if (!d)
+		{
+			clear();
+		} else {
+			size_t len = strlen(d);
+			Grow(len + 1, false);
+			memcpy(v, d, len);
+			v[len] = '\0';
+		}
+	}
+
+	void clear()
+	{
+		if (v)
+			v[0] = '\0';
+	}
+
+	int compare (const char *d) const
+	{
+		if (!v)
+			return strcmp("", d);
+		else
+			return strcmp(v, d);
+	}
+
+	//Added this for amxx inclusion
+	bool empty()
+	{
+		if (!v)
+			return true;
+
+		if (v[0] == '\0')
+			return true;
+
+		return false;
+	}
+
+	size_t size()
+	{
+		if (v)
+			return strlen(v);
+		else
+			return 0;
+	}
+
+	int find(const char c, int index = 0)
+	{
+		int len = static_cast<int>(size());
+		if (len < 1)
+			return npos;
+		if (index >= len || index < 0)
+			return npos;
+		int i = 0;
+		for (i=index; i<len; i++)
+		{
+			if (v[i] == c)
+			{
+				return i;
+			}
+		}
+
+		return npos;
+	}
+
+	bool is_space(int c)
+	{
+		if (c == '\f' || c == '\n' ||
+			c == '\t' || c == '\r' ||
+			c == '\v' || c == ' ')
+		{
+			return true;
+		}
+
+		return false;
+	}
+
+	void reparse_newlines()
+	{
+		size_t len = size();
+		int offs = 0;
+		char c;
+		if (!len)
+			return;
+		for (size_t i=0; i<len; i++)
+		{
+			c = v[i];
+			if (c == '^' && (i != len-1))
+			{
+				c = v[++i];
+				if (c == 'n')
+					c = '\n';
+				else if (c == 't')
+					c = '\t';
+				offs++;
+			}
+			v[i-offs] = c;
+		}
+		v[len-offs] = '\0';
+	}
+	
+	void trim()
+	{
+		if (!v)
+			return;
+
+		unsigned int i = 0;
+		unsigned int j = 0;
+		size_t len = strlen(v);
+
+		if (len == 1)
+		{
+			if (is_space(v[i]))
+			{
+				clear();
+				return;
+			} 
+		}
+
+		unsigned char c0 = v[0];
+
+		if (is_space(c0))
+		{
+			for (i=0; i<len; i++)
+			{
+				if (!is_space(v[i]) || (is_space(v[i]) && ((unsigned char)i==len-1)))
+				{
+					erase(0, i);
+					break;
+				}
+			}
+		}
+
+		len = strlen(v);
+
+		if (len < 1)
+		{
+			return;
+		}
+
+		if (is_space(v[len-1]))
+		{
+			for (i=len-1; i>=0; i--)
+			{
+				if (!is_space(v[i])
+					|| (is_space(v[i]) && i==0))
+				{
+					erase(i+1, j);
+					break;
+				}
+				j++;
+			}
+		}
+
+		if (len == 1)
+		{
+			if (is_space(v[0]))
+			{
+				clear();
+				return;
+			}
+		}
+	}
+
+	void erase(unsigned int start, int num = npos)
+	{
+		if (!v)
+			return;
+		unsigned int i = 0;
+		size_t len = size();
+		//check for bounds
+		if (num == npos || start+num > len-start)
+			num = len - start;
+		//do the erasing
+		bool copyflag = false;
+		for (i=0; i<len; i++)
+		{
+			if (i>=start && i<start+num)
+			{
+				if (i+num < len)
+				{	
+					v[i] = v[i+num];
+				} else {
+					v[i] = 0;
+				}
+				copyflag = true;
+			} else if (copyflag) {
+				if (i+num < len)
+				{
+					v[i] = v[i+num];
+				} else {
+					v[i] = 0;
+				}
+			}
+		}
+		len -= num;
+		v[len] = 0;
+	}
+
+	String substr(unsigned int index, int num = npos)
+	{
+		if (!v)
+		{
+			String b("");
+			return b;
+		}
+
+		String ns;
+
+		size_t len = size();
+
+		if (index >= len || !v)
+			return ns;
+		
+		if (num == npos)
+		{
+			num = len - index;
+		} else if (index+num >= len) {
+			num = len - index;
+		}
+
+		unsigned int i = 0;
+		unsigned int nslen = num + 2;
+
+		ns.Grow(nslen);
+
+		for (i=index; i<index+num; i++)
+			ns.append(v[i]);
+
+		return ns;
+	}
+
+	void toLower()
+	{
+		if (!v)
+			return;
+		unsigned int i = 0;
+		size_t len = strlen(v);
+		for (i=0; i<len; i++)
+		{
+			if (v[i] >= 65 && v[i] <= 90)
+				v[i] &= ~(1<<5);
+		}
+	}
+
+	String & operator = (const String &src)
+	{
+		assign(src);
+		return *this;
+	}
+
+	String & operator = (const char *src)
+	{
+		assign(src);
+		return *this;
+
+	}
+
+	char operator [] (unsigned int index)
+	{
+		if (index > size() || !v)
+		{
+			return -1;
+		} else {
+			return v[index];
+		}
+	}
+
+	int at(int a)
+	{
+		if (a < 0 || a >= (int)size() || !v)
+			return -1;
+
+		return v[a];
+	}
+
+	bool at(int at, char c)
+	{
+		if (at < 0 || at >= (int)size() || !v)
+			return false;
+
+		v[at] = c;
+
+		return true;
+	}
+
+private:
+	void Grow(unsigned int d, bool copy=true)
+	{
+		if (d <= a_size)
+			return;
+		char *n = new char[d + 1];
+		if (copy && v)
+			strcpy(n, v);
+		if (v)
+			delete [] v;
+		else
+			strcpy(n, "");			
+		v = n;
+		a_size = d + 1;
+	}
+
+	char *v;
+	unsigned int a_size;
+public:
+	static const int npos = -1;
+};
+
+#endif //_INCLUDE_CSTRING_H
diff --git a/dlls/hamsandwich/CVector.h b/dlls/hamsandwich/CVector.h
new file mode 100644
index 00000000..d0fef2be
--- /dev/null
+++ b/dlls/hamsandwich/CVector.h
@@ -0,0 +1,491 @@
+/* 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)
+		{
+			for (size_t i=0; i<m_CurrentUsedSize; i++)
+				newData[i] = m_Data[i];
+			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;
+
+		if (!size)
+		{
+			if (m_Data)
+			{
+				delete [] m_Data;
+				m_Data = NULL;
+				m_Size = 0;
+			}
+			return true;
+		}
+
+		T *newData = new T[size];
+		if (!newData)
+			return false;
+		if (m_Data)
+		{
+			size_t end = (m_CurrentUsedSize < size) ? (m_CurrentUsedSize) : size;
+			for (size_t i=0; i<end; i++)
+				newData[i] = m_Data[i];
+			delete [] m_Data;
+		}
+		m_Data = newData;
+		m_Size = size;
+		if (m_CurrentUsedSize > m_Size)
+			m_CurrentUsedSize = m_Size;
+
+		return true;
+	}
+
+	void FreeMemIfPossible()
+	{
+		if (!m_Data)
+			return;
+
+		if (!m_CurrentUsedSize)
+		{
+			ChangeSize(0);
+			return;
+		}
+
+		size_t newSize = m_Size;
+		while (m_CurrentUsedSize <= newSize / 2)
+			newSize /= 2;
+
+		if (newSize != m_Size)
+			ChangeSize(newSize);
+	}
+protected:
+	T *m_Data;
+	size_t m_Size;
+	size_t m_CurrentUsedSize;
+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_CurrentUsedSize];
+		m_Size = other.m_CurrentUsedSize;
+		m_CurrentUsedSize = other.m_CurrentUsedSize;
+		for (size_t i=0; i<other.m_CurrentUsedSize; i++)
+			m_Data[i] = other.m_Data[i];
+	}
+
+	~CVector<T>()
+	{
+		clear();
+	}
+
+	// interface
+	size_t size() const
+	{
+		return m_CurrentUsedSize;
+	}
+
+	size_t capacity() const
+	{
+		return m_Size;
+	}
+
+	iterator begin() const
+	{
+		return iterator(m_Data);
+	}
+
+	iterator end() const
+	{
+		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)
+	{
+		if (newSize > m_Size)
+			return ChangeSize(newSize);
+		return true;
+	}
+
+	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;
+
+		FreeMemIfPossible();
+	}
+
+	bool resize(size_t newSize)
+	{
+		if (!ChangeSize(newSize))
+			return false;
+		m_CurrentUsedSize = newSize;
+		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];
+	}
+
+	iterator insert(iterator where, const T & value)
+	{
+		// validate iter
+		if (where < m_Data || where > (m_Data + m_CurrentUsedSize))
+			return iterator(0);
+
+		size_t ofs = where - begin();
+
+		++m_CurrentUsedSize;
+		if (!GrowIfNeeded())
+		{
+			--m_CurrentUsedSize;
+			return false;
+		}
+
+		where = begin() + ofs;
+
+		// Move subsequent entries
+		for (T *ptr = m_Data + m_CurrentUsedSize - 2; ptr >= where.base(); --ptr)
+			*(ptr + 1) = *ptr;
+
+		*where.base() = value;
+
+		return where;
+	}
+
+	iterator erase(iterator where)
+	{
+		// validate iter
+		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
+			return iterator(0);
+
+		size_t ofs = where - begin();
+
+		if (m_CurrentUsedSize > 1)
+		{
+			// move
+			T *theend = m_Data + m_CurrentUsedSize;
+			for (T *ptr = where.base() + 1; ptr < theend; ++ptr)
+				*(ptr - 1) = *ptr;
+		}
+
+		--m_CurrentUsedSize;
+
+		FreeMemIfPossible();
+
+		return begin() + ofs;
+	}
+
+	void clear()
+	{
+		m_Size = 0;
+		m_CurrentUsedSize = 0;
+		if (m_Data)
+		{
+			delete [] m_Data;
+			m_Data = NULL;
+		}
+	}
+};
+
+#endif // __CVECTOR_H__
+
diff --git a/dlls/hamsandwich/Makefile b/dlls/hamsandwich/Makefile
new file mode 100644
index 00000000..29501620
--- /dev/null
+++ b/dlls/hamsandwich/Makefile
@@ -0,0 +1,101 @@
+#(C)2004-2005 AMX Mod X Development Team
+# Makefile written by David "BAILOPAN" Anderson
+
+HLSDK = ../../../hlsdk
+MM_ROOT = ../../metamod/metamod
+
+### EDIT BELOW FOR OTHER PROJECTS ###
+
+
+CRAZY_OPT_FLAGS = -DCRAZY_OPTS -O3 -funroll-loops -ffast-math -s -pipe -fomit-frame-pointer -fno-strict-aliasing -DNDEBUG -fmerge-all-constants -fmodulo-sched -fgcse-sm -fgcse-las -fgcse-after-reload -floop-optimize2 -funsafe-loop-optimizations -ftree-loop-linear -ftree-loop-im -ftree-loop-ivcanon -fivopts -ftree-vectorize -fvariable-expansion-in-unroller -funsafe-math-optimizations -ffinite-math-only  -fpeel-loops -funswitch-loops -fvisibility=hidden -fvisibility-inlines-hidden -fPIC -Wall -Wno-unknown-pragmas -Wno-deprecated -fno-exceptions -DHAVE_STDINT_H -static-libgcc -fno-rtti -Wpointer-arith -Wcast-qual -Wcast-align -Wconversion -Wsign-compare -Wmissing-noreturn -Winline -Wlong-long -Wunsafe-loop-optimizations -Wctor-dtor-privacy -Wno-non-virtual-dtor -Wreorder -Woverloaded-virtual -Wsign-promo -Wsynth -shared 
+
+CRAZY_LINK_FLAGS = -fwhole-program
+#-fwhole-program -combine
+
+SANE_OPT_FLAGS = -O3 -funroll-loops -s -pipe -fomit-frame-pointer -fno-strict-aliasing -DNDEBUG
+
+OPT_FLAGS =
+
+DEBUG_FLAGS = -g -ggdb3
+CPP = gcc-4.1
+#CPP = gcc-2.95
+NAME = hamsandwich
+
+BIN_SUFFIX = amxx_i386.so
+
+OBJECTS = sdk/amxxmodule.cpp amxx_api.cpp    config_parser.cpp  \
+hook_callbacks.cpp  hook_native.cpp srvcmd.cpp \
+call_funcs.cpp  ecall_funcs.cpp    hook_create.cpp 
+
+
+LINK = 
+
+INCLUDE = -I. -I$(HLSDK) -I$(HLSDK)/dlls -I$(HLSDK)/engine -I$(HLSDK)/game_shared -I$(HLSDK)/game_shared \
+	-I$(MM_ROOT) -I$(HLSDK)/common -I$(HLSDK)/pm_shared -I./tableentries
+
+GCC_VERSION := $(shell $(CPP) -dumpversion >&1 | cut -b1)
+
+ifeq "$(DEBUG)" "true"
+	BIN_DIR = Debug
+	CFLAGS = $(DEBUG_FLAGS)
+else
+	ifeq "$(CRAZY)" "true"
+		BIN_DIR = Optimized
+		OPT_FLAGS = $(CRAZY_OPT_FLAGS)
+		LINK = $(CRAZY_LINK_FLAGS)
+	else
+		BIN_DIR = Release
+		OPT_FLAGS = $(SANE_OPT_FLAGS)
+	endif
+	ifeq "$(GCC_VERSION)" "4"
+		OPT_FLAGS += -fvisibility=hidden -fvisibility-inlines-hidden
+	endif
+	CFLAGS = $(OPT_FLAGS)
+endif
+
+CFLAGS += -fPIC -Wall -Wno-non-virtual-dtor -fno-exceptions -DHAVE_STDINT_H -fno-rtti
+
+BINARY = $(NAME)_$(BIN_SUFFIX)
+CFLAGS += -DPAWN_CELL_SIZE=32 -DJIT -DASM32
+OPT_FLAGS += -march=i586
+
+OBJ_LINUX := $(OBJECTS:%.cpp=$(BIN_DIR)/%.o)
+
+$(BIN_DIR)/%.o: %.cpp
+	$(CPP) $(INCLUDE) $(CFLAGS) -o $@ -c $<
+
+all:
+	mkdir -p $(BIN_DIR)
+	mkdir -p $(BIN_DIR)/sdk
+	mkdir -p $(BIN_DIR)/natives
+	mkdir -p $(BIN_DIR)/tableentries
+	$(MAKE) hamsandwich
+
+hamsandwich: $(OBJ_LINUX)
+	$(CPP) $(INCLUDE) $(CFLAGS) $(OBJ_LINUX) $(LINK) -shared -ldl -lm -o$(BIN_DIR)/$(BINARY)
+
+debug:	
+	$(MAKE) all DEBUG=true
+
+default: all
+
+crazy:
+	$(MAKE) all CRAZY=true
+
+clean:
+	rm -rf Release/*.o
+	rm -rf Release/sdk/*.o
+	rm -rf Release/natives/*.o
+	rm -rf Release/tableentries/*.o
+	rm -rf Release/$(NAME)_$(BIN_SUFFIX)
+	rm -rf Debug/*.o
+	rm -rf Debug/sdk/*.o
+	rm -rf Debug/natives/*.o
+	rm -rf Debug/tableentries/*.o
+	rm -rf Debug/$(NAME)_$(BIN_SUFFIX)
+	rm -rf Optimized/*.o
+	rm -rf Optimized/sdk/*.o
+	rm -rf Optimized/natives/*.o
+	rm -rf Optimized/tableentries/*.o
+	rm -rf Optimized/$(NAME)_$(BIN_SUFFIX)
+	
diff --git a/dlls/hamsandwich/NEW_Util.h b/dlls/hamsandwich/NEW_Util.h
new file mode 100644
index 00000000..c2796a92
--- /dev/null
+++ b/dlls/hamsandwich/NEW_Util.h
@@ -0,0 +1,88 @@
+/* Ham Sandwich
+ *
+ * by sawce
+ *
+ *
+ *  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.
+ */
+
+/* Inlined replacements for INDEXENT/ENTINDEX
+ * It only really removes the overhead of the push/jump
+ * but since INDEXENT/ENTINDEX are used a lot with amxx
+ * it might be beneficial to include.
+ * NOTE: Bad stuff will happen if you call these before
+ *       NEW_Initialize()
+ * NOTE: No bounds checking is done because natives
+ *       should use their own bounds checking!
+ */
+
+#ifndef NEW_UTIL_H
+#define NEW_UTIL_H
+
+
+extern edict_t *NEW_FirstEdict;
+extern bool NEW_Initialized;
+
+/**
+ * This is called on the first Spawn() ever hooked.  This would be worldspawn (index 0)
+ */
+inline void NEW_Initialize(edict_t *Entity)
+{
+	NEW_FirstEdict=Entity;
+	NEW_Initialized=true;
+}
+
+
+/**
+ * Converts an integer index into an edict pointer
+ */
+inline edict_t *INDEXENT_NEW(const int Index)
+{
+	return (edict_t *)(NEW_FirstEdict + Index);
+};
+
+/**
+ * Converts an edict pointer into an integer index
+ */
+inline int ENTINDEX_NEW(const edict_t *Ent)
+{
+	return (int)(Ent - NEW_FirstEdict);
+};
+
+// Inlined replacement of MF_GetAmxAddr
+
+
+inline REAL amx_ctof2(cell x)
+{
+	return *(REAL*)&x;
+}
+inline cell amx_ftoc2(REAL x)
+{
+	return *(cell*)&x;
+}
+
+
+#endif // NEW_UTIL_H
+
diff --git a/dlls/hamsandwich/Trampolines.h b/dlls/hamsandwich/Trampolines.h
new file mode 100644
index 00000000..89cf1b06
--- /dev/null
+++ b/dlls/hamsandwich/Trampolines.h
@@ -0,0 +1,706 @@
+/* Trampolines
+ *
+ *
+ *  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 TRAMPOLINES_H
+#define TRAMPOLINES_H
+
+#ifndef NDEBUG
+#define TPRINT(msg)  printf msg
+#else
+#define TPRINT(msg) /* nothing */
+#endif
+
+#if defined _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif // WIN32_LEAN_AND_MEAN
+#if _MSC_VER >= 1400
+#ifdef offsetof
+#undef offsetof
+#endif // offsetof
+#endif // _MSC_VER >= 1400
+#include <windows.h>
+#elif defined __linux__
+#include <sys/mman.h>
+#include <malloc.h>
+#endif
+#include <stddef.h> // size_t
+#include <string.h> // memcpy
+#include <stdlib.h> // memalign
+#include <stdio.h>
+
+
+namespace Trampolines
+{
+
+	/**
+	 * List of x86 bytecodes for creating
+	 * basic trampolines at runtime.
+	 * -
+	 * These are defined here so that, should
+	 * the need ever arise, this can be ported
+	 * to other architectures fairly painlessly
+	 */
+	namespace Bytecode
+	{
+		/**
+		 * Prologue for a void function
+		 * Clobbers EBX and EAX
+		 */
+		const unsigned char codeVoidPrologue[] = { 
+			0x55,						// push ebp
+			0x89, 0xE5,					// mov ebp, esp
+			0x50,						// push eax
+		};
+
+		/**
+		 * Prologue for a function that returns
+		 * Clobbers EBX, EAX too but not after call
+		 */
+		const unsigned char codeReturnPrologue[] = {
+			0x55,						// push ebp
+			0x89, 0xE5,					// mov ebp, esp
+		};
+		const unsigned char codeThisReturnPrologue[] = {
+			0x55,						// push ebp
+			0x89, 0xE5,					// mov ebp, esp
+		};
+
+
+		/**
+		 * Takes a paramter from the trampoline's stack
+		 * and pushes it onto the target's stack.
+		 */
+		const unsigned char codePushParam[] = {
+			0xFF, 0x75, 0xFF			// pushl [ebp+0xFF]
+		};
+
+		/**
+		 * Offset of codePushParam to modify at runtime
+		 * that contains the stack offset
+		 */
+		const unsigned int codePushParamReplace = 2;
+
+
+		/**
+		 * Takes the "this" pointer from the trampoline and
+		 * pushes it onto the target's stack.
+		 */
+		const unsigned char codePushThis[] = {
+		#if defined _WIN32
+			0x51						// push ecx
+		#elif defined __linux__
+			0xFF, 0x75, 0x04			// pushl [ebp+0x08h]
+		#endif
+		};
+
+#if defined __linux__
+		const int codePushThisReplace = 2;
+#endif
+
+		/**
+		 * Pushes a raw number onto the target's stack
+		 */
+		const unsigned char codePushID[] = {
+			0x68, 0xDE, 0xFA, 0xAD, 0xDE	// push	DEADFADEh
+		};
+
+		/**
+		 * Offset of codePushID to modify at runtime
+		 * to contain the number to push
+		 */
+		const unsigned int codePushIDReplace = 1;
+
+		/**
+		 * Call our procedure
+		 */
+		const unsigned char codeCall[] = {
+			0xB8, 0xDE, 0xFA, 0xAD, 0xDE,// mov eax, DEADFADEh
+			0xFF, 0xD0					// call eax
+		};
+
+		/**
+		 * Offset of codeCall to modify at runtime
+		 * to contain the pointer to the function
+		 */
+		const unsigned int codeCallReplace = 1;
+
+		/**
+		 * Adds to ESP, freeing up stack space
+		 */
+		const unsigned char codeFreeStack[] = {
+			0x81, 0xC4, 0xFF, 0xFF, 0xFF, 0xFF// add esp REPLACEME
+		};
+
+		/**
+		 * Offset of codeFreeStack to modify at runtime
+		 * to contain how much data to free
+		 */
+		const unsigned int codeFreeStackReplace = 2;
+
+		/**
+		 * Epilogue of a simple return function
+		 */
+		const unsigned char codeReturnEpilogue[] = {
+				0x5D,						// pop ebp
+				0xC3						// ret
+		};
+		const unsigned char codeReturnEpilogueN[] = {
+				0x5D,						// pop ebp
+				0xC2, 0xCD, 0xAB			// retn 0xABCD
+		};
+		const int codeReturnEpilogueNReplace = 2;
+
+
+		/**
+		 * Epilogue of a void return function
+		 */
+		const unsigned char codeVoidEpilogue[] = {
+				0x58,						// pop eax
+				0x5D,						// pop ebp
+				0xC3						// ret
+		};
+
+		const unsigned char codeVoidEpilogueN[] = {
+				0x58,						// pop eax
+				0x5D,						// pop ebp
+				0xC2, 0xCD, 0xAB			// retn 0xABCD
+		};
+		const int codeVoidEpilogueNReplace = 3;
+
+
+
+		const unsigned char codeBreakpoint[] = {
+			0xCC							// int 3
+		};
+
+	}
+
+	/**
+	 * Our actual maker of the trampolines!!@$
+	 * I've no idea why I made this a class and not a namespace
+	 * Oh well!
+	 */
+
+	class TrampolineMaker
+	{
+	private:
+		unsigned char		*m_buffer;			// the actual buffer containing the code
+		int					 m_size;			// size of the buffer
+		int					 m_mystack;			// stack for the trampoline itself
+		int					 m_calledstack;		// stack for the target function
+		int					 m_paramstart;
+		int					 m_thiscall;
+		int					 m_maxsize;
+
+		/**
+		 * Adds data to the buffer
+		 * data must be pre-formatted before hand!
+		 */
+		void Append(const unsigned char *src, size_t size)
+		{
+			int orig=m_size;
+			m_size+=size;
+
+			if (m_buffer==NULL)
+			{
+				m_maxsize=512;
+				m_buffer=(unsigned char *)malloc(m_maxsize);
+			}
+			else if (m_size > m_maxsize)
+			{
+				m_maxsize = m_size + 512;
+				m_buffer=(unsigned char *)realloc(m_buffer,m_maxsize);
+			}
+
+			unsigned char *dat=m_buffer+orig; // point dat to the end of the prewritten 
+
+			while (orig<m_size)
+			{
+				*dat++=*src++;
+
+				orig++;
+			};
+
+		};
+	public:
+		TrampolineMaker()
+		{
+			m_buffer=NULL;
+			m_size=0;
+			m_mystack=0;
+			m_calledstack=0;
+			m_paramstart=0;
+			m_thiscall=0;
+			m_maxsize=0;
+		};
+
+		/**
+		 * Inserts a breakpoint (int 3) into the trampoline.
+		 */
+		void Breakpoint()
+		{
+			Append(&::Trampolines::Bytecode::codeBreakpoint[0],sizeof(::Trampolines::Bytecode::codeBreakpoint));
+		};
+
+		/**
+		 * Adds the "return prologue", pushes registers and prepares stack
+		 */
+		void ReturnPrologue()
+		{
+			Append(&::Trampolines::Bytecode::codeReturnPrologue[0],sizeof(::Trampolines::Bytecode::codeReturnPrologue));
+			m_paramstart=0;
+			m_thiscall=0;
+		};
+		void ThisReturnPrologue()
+		{
+			this->ReturnPrologue();
+			m_thiscall=1;
+		};
+
+		/**
+		 * Adds the void prologue pushes registers, prepares the stack
+		 */
+		void VoidPrologue()
+		{
+			Append(&::Trampolines::Bytecode::codeVoidPrologue[0],sizeof(::Trampolines::Bytecode::codeVoidPrologue));
+			m_paramstart=0;
+			m_thiscall=0;
+		};
+
+		/**
+		 * Flags this trampoline as a thiscall trampoline, and prepares the void prologue.
+		 */
+		void ThisVoidPrologue()
+		{
+			this->VoidPrologue();
+			m_thiscall=1;
+		};
+		/**
+		 * Epilogue for a returning function pops registers but does not free any more of the stack!
+		 */
+		void ReturnEpilogue()
+		{
+			Append(&::Trampolines::Bytecode::codeReturnEpilogue[0],sizeof(::Trampolines::Bytecode::codeReturnEpilogue));
+		};
+
+		/**
+		 * Epilogue that also frees it's estimated stack usage.  Useful for stdcall/thiscall/fastcall.
+		 */
+		void ReturnEpilogueAndFree()
+		{
+			this->ReturnEpilogue(m_mystack);
+		};
+
+		/**
+		 * Return epilogue.  Pops registers, and frees given amount of data from the stack.
+		 *
+		 * @param howmuch			How many bytes to free from the stack.
+		 */
+		void ReturnEpilogue(int howmuch)
+		{
+
+			unsigned char code[sizeof(::Trampolines::Bytecode::codeReturnEpilogueN)];
+
+			memcpy(&code[0],&::Trampolines::Bytecode::codeReturnEpilogueN[0],sizeof(::Trampolines::Bytecode::codeReturnEpilogueN));
+
+
+			unsigned char *c=&code[0];
+
+			union 
+			{
+				int		i;
+				unsigned char	b[4];
+			} bi;
+
+			bi.i=howmuch;
+
+			c+=::Trampolines::Bytecode::codeReturnEpilogueNReplace;
+			*c++=bi.b[0];
+			*c++=bi.b[1];
+
+			Append(&code[0],sizeof(::Trampolines::Bytecode::codeReturnEpilogueN));
+			//Append(&::Trampolines::Bytecode::codeReturnEpilogueN[0],sizeof(::Trampolines::Bytecode::codeReturnEpilogueN));
+		};
+
+		/**
+		 * Void epilogue, pops registers and frees the estimated stack usage of the trampoline.
+		 */
+		void VoidEpilogueAndFree()
+		{
+			this->VoidEpilogue(m_mystack);
+		};
+		/**
+		 * Void epilogue, pops registers, nothing else done with stack.
+		 */
+		void VoidEpilogue()
+		{
+			Append(&::Trampolines::Bytecode::codeVoidEpilogue[0],sizeof(::Trampolines::Bytecode::codeVoidEpilogue));
+		};
+		/**
+		 * Void epilogue, pops registers, frees given amount of data off of the stack.
+		 *
+		 * @param howmuch			How many bytes to free from the stack.
+		 */
+		void VoidEpilogue(int howmuch)
+		{
+
+			unsigned char code[sizeof(::Trampolines::Bytecode::codeVoidEpilogueN)];
+
+			memcpy(&code[0],&::Trampolines::Bytecode::codeVoidEpilogueN[0],sizeof(::Trampolines::Bytecode::codeVoidEpilogueN));
+
+
+			unsigned char *c=&code[0];
+
+			union 
+			{
+				int		i;
+				unsigned char	b[4];
+			} bi;
+
+			bi.i=howmuch;
+
+			c+=::Trampolines::Bytecode::codeVoidEpilogueNReplace;
+			*c++=bi.b[0];
+			*c++=bi.b[1];
+
+			Append(&code[0],sizeof(::Trampolines::Bytecode::codeVoidEpilogueN));
+			Append(&::Trampolines::Bytecode::codeVoidEpilogueN[0],sizeof(::Trampolines::Bytecode::codeVoidEpilogueN));
+		};
+
+		/**
+		 * Pushes the "this" pointer onto the callee stack.  Pushes ECX for MSVC, and param0 on GCC.
+		 */
+		void PushThis()
+		{
+
+			if (!m_thiscall)
+			{
+				return;
+			}
+
+			unsigned char code[sizeof(::Trampolines::Bytecode::codePushThis)];
+
+			memcpy(&code[0],&::Trampolines::Bytecode::codePushThis[0],sizeof(::Trampolines::Bytecode::codePushThis));
+
+
+#if defined __linux__
+			unsigned char *c=&code[0];
+
+			union 
+			{
+				int		i;
+				unsigned char	b[4];
+			} bi;
+
+			bi.i=m_paramstart+8;
+
+			c+=::Trampolines::Bytecode::codePushThisReplace;
+			*c++=bi.b[0];
+#endif
+
+			Append(&code[0],sizeof(::Trampolines::Bytecode::codePushThis));
+
+#if defined __linux__
+			TPRINT(("mystack=%d+4\n",m_mystack));
+			m_mystack+=4;
+#endif
+			TPRINT(("calledstack=%d+4\n",m_calledstack));
+			m_calledstack+=4;
+		};
+
+		/**
+		 * Frees what is estimated as the stack usage of the trampoline.
+		 */
+		void FreeMyStack(void)
+		{
+
+			TPRINT(("freeing mystack=%d+4\n",m_mystack));
+			this->FreeStack(m_mystack);
+		};
+
+		/**
+		 * Frees the estimated stack usage of the callee.
+		 */
+		void FreeTargetStack(void)
+		{
+			TPRINT(("freeing calledstack=%d+4\n",m_calledstack));
+			this->FreeStack(m_calledstack);
+		};
+
+
+		/**
+		 * Frees the estimated stack usage of the callee and the trampoline.
+		 */
+		void FreeBothStacks(void)
+		{
+			TPRINT(("freeing mystack=%d+4\n",m_mystack));
+			TPRINT(("freeing calledstack=%d+4\n",m_calledstack));
+			this->FreeStack(m_calledstack + m_mystack);
+		};
+
+		/**
+		 * Frees a given amount of bytes from the stack.
+		 *
+		 * @param howmuch			How many bytes to free.
+		 */
+		void FreeStack(int howmuch)
+		{
+			unsigned char code[sizeof(::Trampolines::Bytecode::codeFreeStack)];
+
+			memcpy(&code[0],&::Trampolines::Bytecode::codeFreeStack[0],sizeof(::Trampolines::Bytecode::codeFreeStack));
+
+			unsigned char *c=&code[0];
+
+			union 
+			{
+				int		i;
+				unsigned char	b[4];
+			} bi;
+
+			bi.i=howmuch;
+
+			c+=::Trampolines::Bytecode::codeFreeStackReplace;
+			*c++=bi.b[0];
+			*c++=bi.b[1];
+			*c++=bi.b[2];
+			*c++=bi.b[3];
+
+			Append(&code[0],sizeof(::Trampolines::Bytecode::codeFreeStack));
+
+		};
+
+		/**
+		 * Pushes a raw number onto the callee stack.
+		 *
+		 * @param Number			The number to push onto the callee stack.
+		 */
+		void PushNum(int Number)
+		{
+			unsigned char code[sizeof(::Trampolines::Bytecode::codePushID)];
+
+			memcpy(&code[0],&::Trampolines::Bytecode::codePushID[0],sizeof(::Trampolines::Bytecode::codePushID));
+
+			unsigned char *c=&code[0];
+
+			union 
+			{
+				int		i;
+				unsigned char	b[4];
+			} bi;
+
+			bi.i=Number;
+
+			c+=::Trampolines::Bytecode::codePushIDReplace;
+			*c++=bi.b[0];
+			*c++=bi.b[1];
+			*c++=bi.b[2];
+			*c++=bi.b[3];
+
+			Append(&code[0],sizeof(::Trampolines::Bytecode::codePushID));
+
+			TPRINT(("calledstack=%d+4\n",m_calledstack));
+			m_calledstack+=4; // increase auto detected stack size
+
+		};
+
+
+		/**
+		 * Takes a parameter passed on the trampoline's stack and inserts it into the callee's stack.
+		 *
+		 * @param which			The parameter number to push. 1-based.  "thiscall" trampolines automatically compensate for the off-number on GCC.
+		 */
+		void PushParam(int which)
+		{
+#if defined __linux__
+			if (m_thiscall)
+			{
+				which++;
+			}
+#endif
+			which=which*4;
+			which+=m_paramstart+4;
+
+			unsigned char value=which;
+
+			unsigned char code[sizeof(::Trampolines::Bytecode::codePushParam)];
+
+			memcpy(&code[0],&::Trampolines::Bytecode::codePushParam[0],sizeof(::Trampolines::Bytecode::codePushParam));
+
+			unsigned char *c=&code[0];
+
+
+			c+=::Trampolines::Bytecode::codePushParamReplace;
+
+			*c=value;
+
+			Append(&code[0],sizeof(::Trampolines::Bytecode::codePushParam));
+
+			TPRINT(("calledstack=%d+4\n",m_calledstack));
+			m_calledstack+=4; // increase auto detected stack size
+			TPRINT(("mystack=%d+4\n",m_mystack));
+			m_mystack+=4;
+
+		};
+
+		/**
+		 * Insert a function to call into the trampoline.
+		 * 
+		 * @param ptr			The function to call, cast to void*.
+		 */
+		void Call(void *ptr)
+		{
+			unsigned char code[sizeof(::Trampolines::Bytecode::codeCall)];
+
+			memcpy(&code[0],&::Trampolines::Bytecode::codeCall[0],sizeof(::Trampolines::Bytecode::codeCall));
+
+			unsigned char *c=&code[0];
+
+			union 
+			{
+				void	*p;
+				unsigned char	 b[4];
+			} bp;
+
+			bp.p=ptr;
+
+			c+=::Trampolines::Bytecode::codeCallReplace;
+
+			*c++=bp.b[0];
+			*c++=bp.b[1];
+			*c++=bp.b[2];
+			*c++=bp.b[3];
+			Append(&code[0],sizeof(::Trampolines::Bytecode::codeCall));
+
+
+		};
+
+		/**
+		 * Finalizes the trampoline.  Do not try to modify it after this.
+		 *
+		 * @param size			A pointer to retrieve the size of the trampoline. Ignored if set to NULL.
+		 * @return				The trampoline pointer, cast to void*.
+		 */
+		void *Finish(int *size)
+		{
+			//void *ret=(void *)m_buffer;
+
+			if (size)
+			{
+				*size=m_size;
+			}
+
+			// Reallocate with proper flags
+#if defined _WIN32
+			void *ret=VirtualAlloc(NULL, m_size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+#elif defined __linux__
+			void *ret=memalign(sysconf(_SC_PAGESIZE), m_size);
+			mprotect(ret,m_size,PROT_READ|PROT_WRITE|PROT_EXEC);
+#endif
+			memcpy(ret, m_buffer, m_size);
+
+
+			m_size=0;
+
+			free(m_buffer);
+
+			m_buffer=NULL; // so we don't accidentally rewrite!
+			m_mystack=0;
+			m_calledstack=0;
+			m_maxsize=512;
+
+			return ret;
+		};
+	};
+};
+
+
+/**
+ * Utility to make a generic trampoline.
+ */
+inline void *CreateGenericTrampoline(bool thiscall, bool voidcall, int paramcount, void *extraptr, void *callee)
+{
+		Trampolines::TrampolineMaker tramp;
+
+	if (voidcall)
+	{
+		if (thiscall)
+		{
+			tramp.ThisVoidPrologue();
+		}
+		else
+		{
+			tramp.VoidPrologue();
+		}
+	}
+	else
+	{
+		if (thiscall)
+		{
+			tramp.ThisReturnPrologue();
+		}
+		else
+		{
+			tramp.ReturnPrologue();
+		}
+	}
+
+	while (paramcount)
+	{
+		tramp.PushParam(paramcount--);
+	}
+	if (thiscall)
+	{
+		tramp.PushThis();
+	}
+	tramp.PushNum(reinterpret_cast<int>(extraptr));
+	tramp.Call(callee);
+	tramp.FreeTargetStack();
+	if (voidcall)
+	{
+#if defined _WIN32
+		tramp.VoidEpilogueAndFree();
+#elif defined __linux__
+		tramp.VoidEpilogue();
+#endif
+	}
+	else
+	{
+#if defined _WIN32
+		tramp.ReturnEpilogueAndFree();
+#elif defined __linux__
+		tramp.ReturnEpilogue();
+#endif
+	}
+	return tramp.Finish(NULL);
+
+};
+
+
+#endif // TRAMPOLINEMANAGER_H
diff --git a/dlls/hamsandwich/amxx_api.cpp b/dlls/hamsandwich/amxx_api.cpp
new file mode 100644
index 00000000..84e78b4a
--- /dev/null
+++ b/dlls/hamsandwich/amxx_api.cpp
@@ -0,0 +1,31 @@
+#include <extdll.h>
+#include "sdk/amxxmodule.h"
+#include "NEW_Util.h"
+
+edict_t *NEW_FirstEdict;
+bool NEW_Initialized;
+
+
+extern AMX_NATIVE_INFO RegisterNatives[];
+
+int ReadConfig(void);
+
+void OnAmxxAttach(void)
+{
+	printf("LOLOL");
+	if (ReadConfig() > 0)
+	{
+		MF_AddNatives(RegisterNatives);
+	}
+}
+
+void HamCommand(void);
+
+void OnPluginsLoaded(void)
+{
+	NEW_Initialize(INDEXENT(0));
+}
+void OnMetaAttach(void)
+{
+	REG_SVR_COMMAND("ham", HamCommand);
+}
diff --git a/dlls/hamsandwich/call_funcs.cpp b/dlls/hamsandwich/call_funcs.cpp
new file mode 100644
index 00000000..db434af4
--- /dev/null
+++ b/dlls/hamsandwich/call_funcs.cpp
@@ -0,0 +1,502 @@
+#include "sdk/amxxmodule.h"
+
+#include "offsets.h"
+#include "ham_utils.h"
+#include "hooklist.h"
+
+#include "CVector.h"
+#include "forward.h"
+#include "hook.h"
+
+#ifdef _WIN32
+#define LOL_CDECL __cdecl
+#else
+#define LOL_CDECL 
+#endif
+
+
+extern CVector<Hook *> hooks[HAM_LAST_ENTRY_DONT_USE_ME_LOL];
+
+void FailPlugin(AMX *amx, int id, int err, const char *reason);
+
+inline void *GetFunction(void *pthis, int id)
+{
+	void **vtbl=GetVTable(pthis, Offsets.GetBase());
+
+	int **ivtbl=(int **)vtbl;
+	void *func=ivtbl[hooklist[id].vtid];
+
+	// Iterate through the hooks for the id, see if the function is found
+	CVector<Hook *>::iterator end=hooks[id].end();
+
+	for (CVector<Hook *>::iterator i=hooks[id].begin();
+		 i!=end;
+		 ++i)
+	{
+		// If the function points to a trampoline, then return the original
+		// function.
+		if (func==(*i)->tramp)
+		{
+			return (*i)->func;
+		}
+	}
+
+	// this is an original function
+	return func;
+}
+
+#define SETUP(NUMARGS)					\
+	if (((NUMARGS + 2) * sizeof(cell)) > (unsigned)params[0])	\
+	{									\
+		MF_LogError(amx, AMX_ERR_NATIVE, "Bad arg count.  Expected %d, got %d.", NUMARGS + 2, params[0] / sizeof(cell));	\
+		return 0;						\
+	}									\
+	int func=params[1];					\
+	int id=params[2];					\
+	CHECK_FUNCTION(func);				\
+	CHECK_ENTITY(id);					\
+	void *pv=IndexToPrivate(id);
+
+
+cell LOL_CDECL Call_Void_Void(AMX *amx, cell *params)
+{
+	SETUP(0);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void*, int)>(GetFunction(pv, func))(pv, 0);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *)>(GetFunction(pv, func))(pv);
+#endif
+	return 1;
+}
+
+cell LOL_CDECL Call_Int_Void(AMX *amx, cell *params)
+{
+	SETUP(0);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void*, int)>(GetFunction(pv, func))(pv, 0);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *)>(GetFunction(pv, func))(pv);
+#endif
+}
+
+cell LOL_CDECL Call_Void_Entvar(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev1=&(INDEXENT_NEW(id3)->v);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void*, int, entvars_t *)>(GetFunction(pv, func))(pv, 0, ev1);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, entvars_t *)>(GetFunction(pv, func))(pv, ev1);
+#endif
+	return 1;
+}
+
+
+cell LOL_CDECL Call_Void_Cbase(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+
+	CHECK_ENTITY(id3);
+
+	void *pv1=(INDEXENT_NEW(id3)->pvPrivateData);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void*, int, void *)>(GetFunction(pv, func))(pv, 0, pv1);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, void *)>(GetFunction(pv, func))(pv, pv1);
+#endif
+	return 1;
+}
+
+cell LOL_CDECL Call_Int_Float_Int(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	float f3=amx_ftoc2(*MF_GetAmxAddr(amx, params[3]));
+	int i4=*MF_GetAmxAddr(amx, params[4]);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void*, int, float, int)>(GetFunction(pv, func))(pv, 0, f3, i4);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, float, int)>(GetFunction(pv, func))(pv, f3, i4);
+#endif
+}
+
+	
+cell LOL_CDECL Call_Void_Entvar_Int(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	int i4=*MF_GetAmxAddr(amx, params[4]);
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void*, int, entvars_t *, int)>(GetFunction(pv, func))(pv, 0, ev3, i4);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, entvars_t *, int)>(GetFunction(pv, func))(pv, ev3, i4);
+#endif
+	return 1;
+}
+
+
+cell LOL_CDECL Call_Int_Cbase(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+
+	CHECK_ENTITY(id3);
+
+	void *pv1=(INDEXENT_NEW(id3)->pvPrivateData);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void*, int, void *)>(GetFunction(pv, func))(pv, 0, pv1);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, void *)>(GetFunction(pv, func))(pv, pv1);
+#endif
+}
+
+cell LOL_CDECL Call_Void_Int_Int(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	int i3=*MF_GetAmxAddr(amx, params[3]);
+	int i4=*MF_GetAmxAddr(amx, params[4]);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void*, int, int, int)>(GetFunction(pv, func))(pv, 0, i3, i4);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, int, int)>(GetFunction(pv, func))(pv, i3, i4);
+#endif
+	return 1;
+}
+
+cell LOL_CDECL Call_Int_Int_Str_Int(AMX *amx, cell *params)
+{
+	
+	SETUP(3);
+
+	int i3=*MF_GetAmxAddr(amx, params[3]);
+	char *sz4=MF_GetAmxString(amx, params[4], 0, NULL);
+	int i5=*MF_GetAmxAddr(amx, params[5]);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void*, int, int, const char *, int)>(GetFunction(pv, func))(pv, 0, i3, sz4, i5);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, int, const char *, int)>(GetFunction(pv, func))(pv, i3, sz4, i5);
+#endif
+}
+
+cell LOL_CDECL Call_Int_Int(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int i3=*MF_GetAmxAddr(amx, params[3]);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void*, int, int)>(GetFunction(pv, func))(pv, 0, i3);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, int)>(GetFunction(pv, func))(pv, i3);
+#endif
+}
+
+cell LOL_CDECL Call_Int_Entvar(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void *, int, entvars_t *)>(GetFunction(pv, func))(pv, 0, ev3);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, entvars_t *)>(GetFunction(pv, func))(pv, ev3);
+#endif
+}
+
+cell LOL_CDECL Call_Int_Entvar_Entvar_Float_Int(AMX *amx, cell *params)
+{
+	SETUP(4);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	int id4=*MF_GetAmxAddr(amx, params[4]);
+	float f5=amx_ctof2(*MF_GetAmxAddr(amx, params[5]));
+	int i6=*MF_GetAmxAddr(amx, params[6]);
+
+	CHECK_ENTITY(id3);
+	CHECK_ENTITY(id4);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+	entvars_t *ev4=&(INDEXENT_NEW(id4)->v);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void *, int, entvars_t *, entvars_t *, float, int)>(GetFunction(pv, func))(pv, 0, ev3, ev4, f5, i6);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, entvars_t *, entvars_t *, float, int)>(GetFunction(pv, func))(pv, ev3, ev4, f5, i6);
+#endif
+}
+
+cell LOL_CDECL Call_Void_Int(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int i3=*MF_GetAmxAddr(amx, params[3]);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void *, int, int)>(GetFunction(pv, func))(pv, 0, i3);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, int)>(GetFunction(pv, func))(pv, i3);
+#endif
+
+	return 1;
+}
+
+cell LOL_CDECL Call_Void_Cbase_Cbase_Int_Float(AMX *amx, cell *params)
+{
+	SETUP(4);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	int id4=*MF_GetAmxAddr(amx, params[4]);
+	int i5=*MF_GetAmxAddr(amx, params[5]);
+	float f6=amx_ctof(*MF_GetAmxAddr(amx, params[6]));
+
+	CHECK_ENTITY(id3);
+	CHECK_ENTITY(id4);
+
+	void *p3=IndexToPrivate(id3);
+	void *p4=IndexToPrivate(id4);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void *, int, void *, void *, int, float)>(GetFunction(pv, func))(pv, 0, p3, p4, i5, f6);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, void *, void *, int, float)>(GetFunction(pv, func))(pv, p3, p4, i5, f6);
+#endif
+
+	return 1;
+}
+
+cell LOL_CDECL Call_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, cell *params)
+{
+	SETUP(5);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4]));
+	Vector v5;
+	TraceResult *tr6=reinterpret_cast<TraceResult *>(*MF_GetAmxAddr(amx, params[6]));
+	int i7=*MF_GetAmxAddr(amx, params[7]);
+
+	float *fl5=(float *)MF_GetAmxAddr(amx, params[5]);
+	v5.x=fl5[0];
+	v5.y=fl5[1];
+	v5.z=fl5[2];
+
+	if (tr6==NULL)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Null traceresult provided.");
+
+		return 0;
+	}
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void *, int, entvars_t *, float, Vector, TraceResult *, int)>(GetFunction(pv, func))(pv, 0, ev3, f4, v5, tr6, i7);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, entvars_t *, float, Vector, TraceResult *, int)>(GetFunction(pv, func))(pv, ev3, f4, v5, tr6, i7);
+#endif
+
+	return 1;
+}
+
+cell LOL_CDECL Call_Void_Float_Vector_TraceResult_Int(AMX *amx, cell *params)
+{
+	SETUP(4);
+
+	float f3=amx_ctof2(*MF_GetAmxAddr(amx, params[3]));
+	Vector v4;
+	TraceResult *tr5=reinterpret_cast<TraceResult *>(*MF_GetAmxAddr(amx, params[5]));
+	int i6=*MF_GetAmxAddr(amx, params[6]);
+
+	float *fl4=(float *)MF_GetAmxAddr(amx, params[4]);
+	v4.x=fl4[0];
+	v4.y=fl4[1];
+	v4.z=fl4[2];
+
+	if (tr5==NULL)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Null traceresult provided.");
+
+		return 0;
+	}
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void *, int, float, Vector, TraceResult *, int)>(GetFunction(pv, func))(pv, 0, f3, v4, tr5, i6);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, float, Vector, TraceResult *, int)>(GetFunction(pv, func))(pv, f3, v4, tr5, i6);
+#endif
+
+	return 1;
+}
+
+cell LOL_CDECL Call_Str_Void(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+#ifdef _WIN32
+	char *v=reinterpret_cast<char *(__fastcall *)(void *, int)>(GetFunction(pv, func))(pv, 0);
+#elif defined __linux__
+	char *v=reinterpret_cast<char *(*)(void *)>(GetFunction(pv, func))(pv);
+#endif
+	return MF_SetAmxString(amx, params[3], v == NULL ? "" : v, *MF_GetAmxAddr(amx, params[4]));
+
+}
+
+cell LOL_CDECL Call_Cbase_Void(AMX *amx, cell *params)
+{
+	SETUP(0);
+#ifdef _WIN32
+	void *ret=reinterpret_cast<void *(__fastcall *)(void *, int)>(GetFunction(pv, func))(pv, 0);
+#elif defined __linux__
+	void *ret=reinterpret_cast<void *(*)(void *)>(GetFunction(pv, func))(pv);
+#endif
+	return PrivateToIndex(ret);
+}
+
+cell LOL_CDECL Call_Vector_Void(AMX *amx, cell *params)
+{
+	SETUP(1);
+#ifdef _WIN32
+	Vector ret=reinterpret_cast<Vector (__fastcall *)(void *, int)>(GetFunction(pv, func))(pv, 0);
+#elif defined __linux__
+	Vector ret=reinterpret_cast<Vector (*)(void *)>(GetFunction(pv, func))(pv);
+#endif
+	float *out=(float *)MF_GetAmxAddr(amx, params[3]);
+	out[0]=ret.x;
+	out[1]=ret.y;
+	out[2]=ret.z;
+
+	return 1;
+}
+
+cell LOL_CDECL Call_Vector_pVector(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	Vector v3;
+	float *fl3=(float *)MF_GetAmxAddr(amx, params[3]);
+	v3.x=fl3[0];
+	v3.y=fl3[1];
+	v3.z=fl3[2];
+
+#ifdef _WIN32
+	Vector ret=reinterpret_cast<Vector (__fastcall *)(void *, int, Vector*)>(GetFunction(pv, func))(pv, 0, &v3);
+#elif defined __linux__
+	Vector ret=reinterpret_cast<Vector (*)(void *, Vector*)>(GetFunction(pv, func))(pv, &v3);
+#endif
+	float *out=(float *)MF_GetAmxAddr(amx, params[4]);
+	out[0]=ret.x;
+	out[1]=ret.y;
+	out[2]=ret.z;
+
+	fl3[0]=v3.x;
+	fl3[1]=v3.y;
+	fl3[2]=v3.z;
+
+	return 1;
+}
+
+cell LOL_CDECL Call_Int_pVector(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	Vector v3;
+	float *fl3=(float *)MF_GetAmxAddr(amx, params[3]);
+	v3.x=fl3[0];
+	v3.y=fl3[1];
+	v3.z=fl3[2];
+
+#ifdef _WIN32
+	int ret=reinterpret_cast<int (__fastcall *)(void *, int, Vector*)>(GetFunction(pv, func))(pv, 0, &v3);
+#elif defined __linux__
+	int ret=reinterpret_cast<int (*)(void *, Vector*)>(GetFunction(pv, func))(pv, &v3);
+#endif
+
+	fl3[0]=v3.x;
+	fl3[1]=v3.y;
+	fl3[2]=v3.z;
+
+	return ret;
+}
+
+cell LOL_CDECL Call_Void_Entvar_Float_Float(AMX *amx, cell *params)
+{
+	SETUP(3);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4]));
+	float f5=amx_ctof2(*MF_GetAmxAddr(amx, params[5]));
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void *, int, entvars_t *, float, float)>(GetFunction(pv, func))(pv, 0, ev3, f4, f5);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, entvars_t *, float, float)>(GetFunction(pv, func))(pv, ev3, f4, f5);
+#endif
+
+	return 1;
+}
+
+cell LOL_CDECL Call_Int_pFloat_pFloat(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	float f3=amx_ctof2(*MF_GetAmxAddr(amx, params[3]));
+	float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4]));
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void *, int, float*, float*)>(GetFunction(pv, func))(pv, 0, &f3, &f4);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, float*, float*)>(GetFunction(pv, func))(pv, &f3, &f4);
+#endif
+
+}
+
+cell LOL_CDECL Call_Void_Entvar_Float(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4]));
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void *, int, entvars_t*, float)>(GetFunction(pv, func))(pv, 0, ev3, f4);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, entvars_t*, float)>(GetFunction(pv, func))(pv, ev3, f4);
+#endif
+}
+
diff --git a/dlls/hamsandwich/call_funcs.h b/dlls/hamsandwich/call_funcs.h
new file mode 100644
index 00000000..150a3009
--- /dev/null
+++ b/dlls/hamsandwich/call_funcs.h
@@ -0,0 +1,54 @@
+#ifndef HOOK_Call_H
+#define HOOK_Call_H
+
+
+int Call_Void_Void(AMX *amx, cell *params);
+
+int Call_Int_Void(AMX *amx, cell *params);
+
+int Call_Void_Entvar(AMX *amx, cell *params);
+
+int Call_Void_Cbase(AMX *amx, cell *params);
+
+int Call_Int_Float_Int(AMX *amx, cell *params);
+	
+int Call_Void_Entvar_Int(AMX *amx, cell *params);
+
+int Call_Int_Cbase(AMX *amx, cell *params);
+
+int Call_Void_Int_Int(AMX *amx, cell *params);
+
+int Call_Int_Int_Str_Int(AMX *amx, cell *params);
+
+int Call_Int_Int(AMX *amx, cell *params);
+
+int Call_Int_Entvar(AMX *amx, cell *params);
+
+int Call_Int_Entvar_Entvar_Float_Int(AMX *amx, cell *params);
+
+int Call_Void_Int(AMX *amx, cell *params);
+
+int Call_Void_Cbase_Cbase_Int_Float(AMX *amx, cell *params);
+
+int Call_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, cell *params);
+
+int Call_Void_Float_Vector_TraceResult_Int(AMX *amx, cell *params);
+
+int Call_Str_Void(AMX *amx, cell *params);
+
+int Call_Cbase_Void(AMX *amx, cell *params);
+
+int Call_Vector_Void(AMX *amx, cell *params);
+
+int Call_Vector_pVector(AMX *amx, cell *params);
+
+int Call_Int_pVector(AMX *amx, cell *params);
+
+int Call_Void_Entvar_Float_Float(AMX *amx, cell *params);
+
+int Call_Int_pFloat_pFloat(AMX *amx, cell *params);
+
+int Call_Void_Entvar_Float(AMX *amx, cell *params);
+
+
+#endif
diff --git a/dlls/hamsandwich/celltotype.h b/dlls/hamsandwich/celltotype.h
new file mode 100644
index 00000000..57f4581a
--- /dev/null
+++ b/dlls/hamsandwich/celltotype.h
@@ -0,0 +1,54 @@
+#ifndef CELLTOTYPE_H
+#define CELLTOTYPE_H
+
+#include <extdll.h>
+#include "sdk/amxxmodule.h"
+
+#include "CVector.h"
+
+#include "hook.h"
+#include "forward.h"
+
+#include "ham_const.h"	
+#include "ham_utils.h"
+
+inline void CellToType(const AMX*& amx, const cell& in, int& out)
+{
+	out=static_cast<int>(in);
+}
+
+inline void CellToType(const AMX*& amx, const cell& in, float& out)
+{
+	out=amx_ctof2(in);
+}
+
+inline void CellToType(const AMX*& amx, const cell& in, edict_t*& out)
+{
+	out=INDEXENT_NEW(in);
+}
+
+inline void CellToType(const AMX*& amx, const cell& in, entvars_t*& out)
+{
+	out=&(INDEXENT_NEW(in)->v);
+}
+
+inline void CellToType(const AMX*& amx, const cell& in, HLBaseEntity*& out)
+{
+	out=(HLBaseEntity *)(INDEXENT_NEW(in)->pvPrivateData);
+}
+
+inline void CellToType(const AMX*& amx, const cell& in, Vector& out)
+{
+	float *v=(float *)MF_GetAmxAddr(amx, in);
+
+	out.x=v[0];
+	out.y=v[1];
+	out.z=v[2];
+}
+
+inline void CellToType(const AMX*& amx, const cell& in, TraceResult*& out)
+{
+	out=reinterpret_cast<TraceResult*>(in);
+}
+
+#endif
diff --git a/dlls/hamsandwich/config/hamdata.ini b/dlls/hamsandwich/config/hamdata.ini
new file mode 100644
index 00000000..df7f0b0b
--- /dev/null
+++ b/dlls/hamsandwich/config/hamdata.ini
@@ -0,0 +1,690 @@
+; Ham Sandwich module config file.
+; 
+; IMPORTANT: It is highly suggested that you do not modify this file unless
+;            you know _exactly_ what you are doing!
+;
+; NOTE: Just because a mod contains a function does not means it will work
+;       as expected.  If, for example, HamKilled() does not work as you think
+;       it should in Counter-Strike DO NOT FILE A BUG REPORT.  This just
+;       exposes the function for you, whether or not it works, or how it
+;       works is up to plugin authors to figure out.
+;
+; NOTE: If a mod is missing keys for a certain native, that particular native
+;       will not be loaded! Example: Say CS is missing the "takedamage" index
+;       but has the use and pev indexes.  The HamUse and HamePdataCbase natives
+;       will be registered, but the HamTakeDamage native will not register.
+;       In addition, any attempts to hook a function who's key is missing will
+;       result in the plugin failing.
+;
+; NOTE: The base key is only needed for the linux configs.
+;
+; NOTE: Any keys that begin with a modname (eg: cstrike_restart) will, 
+;       obviously, only work on that mod and all mirrors of it (eg: czero).
+;
+; NOTE: If you change this file while the module is already loaded, you will
+;       need to restart the server for the changes to take effect.  Changes to
+;       this file before the module is loaded will take effect when the module
+;       loads.
+;
+; NOTE: All of these offsets and settings are for the latest (at the time of
+;       release) legitimate version of the mod.  However, there is a _chance_
+;       that they will work on older (and even newer) versions.
+;       eg: If they work on non-Steam CS 1.6 this is coincidental, if they do 
+;           not work on non-Steam CS 1.6 this will not be officially fixed.
+;
+; Mirrors: These take the name of one mod, and copy all of its data to another
+;          name. An example of a use for this would be cstrike and czero: they
+;          use the same binary so all of its vtable offsets are guaranteed to
+;          be identical. Mirrors should always come first in the file!
+;
+; Version: $Id$
+
+
+@mirror cstrike czero
+@mirror ns nsp
+@mirror esf esf_openbeta
+
+; TODO: check these - all are estimates
+@section cstrike linux
+	pev 0
+	base 0x94
+	
+	spawn 2
+	precache 3
+	cstrike_restart 4
+	keyvalue 5
+	objectcaps 8
+	activate 9
+	setobjectcollisionbox 10
+	classify 11
+	deathnotice 12
+	traceattack 13
+	takedamage 14
+	takehealth 15
+	killed 16
+	bloodcolor 17
+	tracebleed 18
+	istriggered 19
+	gettogglestate 22
+	addpoints 23
+	addpointstoteam 24
+	addplayeritem 25
+	removeplayeritem 26
+	giveammo 27
+	getdelay 28
+	ismoving 29
+	overridereset 30
+	damagedecal 31
+	settogglestate 32
+	startsneaking 33
+	stopsneaking 34
+	oncontrols 35
+	issneaking 36
+	isalive 37
+	isbspmodel 38
+	reflectgauss 39
+	hastarget 40
+	isinworld 41
+	isplayer 42
+	isnetclient 43
+	teamid 44
+	getnexttarget 45
+	think 46
+	touch 47
+	use 48
+	blocked 49
+	respawn 50
+	updateowner 51
+	fbecomeprone 52
+	center 53
+	eyeposition 54
+	earposition 55
+	bodytarget 56
+	illumination 57
+	fvisible 58
+	fvecvisible 59
+@end
+@section cstrike windows
+	pev 4
+	base 0x0
+	
+	spawn 0
+	precache 1
+	cstrike_restart 2
+	keyvalue 3
+	objectcaps 6
+	activate 7
+	setobjectcollisionbox 8
+	classify 9
+	deathnotice 10
+	traceattack 11
+	takedamage 12
+	takehealth 13
+	killed 14
+	bloodcolor 15
+	tracebleed 16
+	istriggered 17
+	gettogglestate 20
+	addpoints 21
+	addpointstoteam 22
+	addplayeritem 23
+	removeplayeritem 24
+	giveammo 25
+	getdelay 26
+	ismoving 27
+	overridereset 28
+	damagedecal 29
+	settogglestate 30
+	startsneaking 31
+	stopsneaking 32
+	oncontrols 33
+	issneaking 34
+	isalive 35
+	isbspmodel 36
+	reflectgauss 37
+	hastarget 38
+	isinworld 39
+	isplayer 40
+	isnetclient 41
+	teamid 42
+	getnexttarget 43
+	think 44
+	touch 45
+	use 46
+	blocked 47
+	respawn 48
+	updateowner 49
+	fbecomeprone 50
+	center 51
+	eyeposition 52
+	earposition 53
+	bodytarget 54
+	illumination 55
+	fvisible 56
+	fvecvisible 57
+@end
+@section dod linux
+	pev 0
+	base 0x154
+	
+	dod_roundrespawn 2
+	dod_roundrespawnent 3
+	dod_roundstore 4
+	spawn 5
+	precache 6
+	keyvalue 7
+	objectcaps 10
+	activate 11
+	dod_areasetindex 12
+	dod_areasendstatus 13
+	objectcollisionbox 14
+	classify 15
+	deathnotice 16
+	dod_getstate 17
+	dod_getstateent 18
+	traceattack 19
+	takedamage 20
+	takehealth 21
+	killed 22
+	bloodcolor 23
+	tracebleed 24
+	gettogglestate 27
+	addpoints 28
+	addpointstoteam 29
+	addplayeritem 30
+	removeplayeritem 31
+	giveammo 32
+	getdelay 33
+	ismoving 34
+	overridereset 35
+	damagedecal 36
+	settogglestate 37
+	startsneaking 38
+	stopsneaking 39
+	oncontrols 40
+	issneaking 41
+	isalive 42
+	isbspmodel 43
+	reflectgauss 44
+	hastarget 45
+	isinworld 46
+	isplayer 47
+	isnetclient 48
+	teamid 49
+	getnexttarget 50
+	touch 51
+	think 52
+	use 53
+	blocked 54
+	respawn 55
+	updateowner 56
+	fbecomeprone 57
+	center 58
+	eyeposition 59
+	earposition 60
+	bodytarget 61
+	illumination 62
+	fvisible 63
+	fvecvisible 64
+@end
+@section dod windows
+	pev 4
+	base 0x0
+	
+	dod_roundrespawn 0
+	dod_roundrespawnent 1
+	dod_roundstore 2
+	spawn 3
+	precache 4
+	keyvalue 5
+	objectcaps 8
+	activate 9
+	dod_areasetindex 10
+	dod_areasendstatus 11
+	objectcollisionbox 12
+	classify 13
+	deathnotice 14
+	dod_getstate 15
+	dod_getstateent 16
+	traceattack 17
+	takedamage 18
+	takehealth 19
+	killed 20
+	bloodcolor 21
+	tracebleed 22
+	gettogglestate 25
+	addpoints 26
+	addpointstoteam 27
+	addplayeritem 28
+	removeplayeritem 29
+	giveammo 30
+	getdelay 31
+	ismoving 32
+	overridereset 33
+	damagedecal 34
+	settogglestate 35
+	startsneaking 36
+	stopsneaking 37
+	oncontrols 48
+	issneaking 39
+	isalive 40
+	isbspmodel 41
+	reflectgauss 42
+	hastarget 43
+	isinworld 44
+	isplayer 45
+	isnetclient 46
+	teamid 47
+	getnexttarget 48
+	touch 49
+	think 50
+	use 51
+	blocked 52
+	respawn 53
+	updateowner 54
+	fbecomeprone 55
+	center 56
+	eyeposition 57
+	earposition 58
+	bodytarget 59
+	illumination 60
+	fvisible 61
+	fvecvisible 62
+@end
+
+; TFC Does not have the following "standard" entries in its vtable:
+; addpoints, addpointstoteam
+@section tfc linux
+	pev 0
+	base 0x470
+	
+	spawn 3
+	precache 4
+	keyvalue 5
+	objectcaps 8
+	activate 9
+	setobjectcollisionbox 10
+	classify 11
+	deathnotice 12
+	traceattack 13
+	takedamage 14
+	takehealth 15
+	killed 16
+	bloodcolor 17
+	tracebleed 18
+	istriggered 19
+	gettogglestate 22
+	addplayeritem 23
+	removeplayeritem 24
+	giveammo 25
+	getdelay 26
+	ismoving 27
+	overridereset 28
+	damagedecal 29
+	settogglestate 30
+	startsneaking 31
+	stopsneaking 32
+	oncontrols 33
+	issneaking 34
+	isalive 35
+	isbspmodel 36
+	reflectgauss 37
+	hastarget 38
+	isinworld 39
+	isplayer 40
+	isnetclient 41
+	tfc_dbgetitemname 42
+	getnexttarget 43
+	think 44
+	touch 45
+	use 46
+	blocked 47
+	respawn 48
+	updateowner 49
+	fbecomeprone 50
+	center 51
+	eyeposition 52
+	earposition 53
+	bodytarget 54
+	illumination 55
+	fvisible 56
+	fvecvisible 57
+	tfc_engineeruse 58
+	tfc_finished 59
+	tfc_empexplode 60
+	tfc_calcempdmgrad 61
+	tfc_takeempblast 62
+	tfc_empremove 63
+	tfc_takeconcussionblast 64
+	tfc_concuss 65
+@end
+@section tfc windows
+	pev 4
+	base 0x0
+	
+	spawn 1
+	precache 2
+	keyvalue 3
+	objectcaps 6
+	activate 7
+	setobjectcollisionbox 8
+	classify 9
+	deathnotice 10
+	traceattack 11
+	takedamage 12
+	takehealth 13
+	killed 14
+	bloodcolor 15
+	tracebleed 16
+	istriggered 17
+	gettogglestate 20
+	addplayeritem 21
+	removeplayeritem 22
+	giveammo 23
+	getdelay 24
+	ismoving 25
+	overridereset 26
+	damagedecal 27
+	settogglestate 28
+	startsneaking 29
+	stopsneaking 30
+	oncontrols 31
+	issneaking 32
+	isalive 33
+	isbspmodel 34
+	reflectgauss 35
+	hastarget 36
+	isinworld 37
+	isplayer 38
+	isnetclient 39
+	tfc_dbgetitemname 40
+	getnexttarget 41
+	think 42
+	touch 43
+	use 44
+	blocked 45
+	respawn 46
+	updateowner 47
+	fbecomeprone 48
+	center 49
+	eyeposition 50
+	earposition 51
+	bodytarget 52
+	illumination 53
+	fvisible 54
+	fvecvisible 55
+	tfc_engineeruse 56
+	tfc_finished 57
+	tfc_empexplode 58
+	tfc_calcempdmgrad 59
+	tfc_takeempblast 60
+	tfc_empremove 61
+	tfc_takeconcussionblast 62
+	tfc_concuss 63
+@end
+; ns's linux binary is compiled with gcc 3.3, so the "base" is 0, and pev is 4
+@section ns linux
+	pev 4
+	base 0x0
+	
+	spawn 1
+	precache 2
+	keyvalue 3
+	objectcaps 6
+	activate 7
+	setobjectcollisionbox 8
+	classify 9
+	deathnotice 10
+	traceattack 11
+	takedamage 12
+	takehealth 13
+	ns_getpointvalue 14
+	killed 15
+	ns_awardkill 16
+	bloodcolor 17
+	tracebleed 18
+	istriggered 19
+	gettogglestate 22
+	addpoints 23
+	addpointstoteam 24
+	addplayeritem 25
+	removeplayeritem 26
+	giveammo 27
+	getdelay 28
+	ismoving 29
+	overridereset 30
+	damagedecal 31
+	settogglestate 32
+	startsneaking 33
+	stopsneaking 34
+	oncontrols 35
+	issneaking 36
+	isalive 37
+	isbspmodel 38
+	reflectgauss 39
+	hastarget 40
+	isinworld 41
+	isplayer 42
+	isnetclient 43
+	teamid 44
+	ns_resetentity 46
+	getnexttarget 47
+	think 48
+	touch 49
+	use 50
+	blocked 51
+	ns_updateonremove 52
+	respawn 53
+	updateowner 54
+	fbecomeprone 55
+	center 56
+	eyeposition 57
+	earposition 58
+	bodytarget 59
+	illumination 60
+	fvisible 61
+	fvecvisible 62
+@end
+@section ns windows
+	pev 4
+	base 0x0
+	
+	spawn 0
+	precache 1
+	keyvalue 2
+	objectcaps 5
+	activate 6
+	setobjectcollisionbox 7
+	classify 8
+	deathnotice 9
+	traceattack 10
+	takedamage 11
+	takehealth 12
+	ns_getpointvalue 13
+	killed 14
+	ns_awardkill 15
+	bloodcolor 16
+	tracebleed 17
+	istriggered 18
+	gettogglestate 21
+	addpoints 22
+	addpointstoteam 23
+	addplayeritem 24
+	removeplayeritem 25
+	giveammo 26
+	getdelay 27
+	ismoving 28
+	overridereset 29
+	damagedecal 30
+	settogglestate 31
+	startsneaking 32
+	stopsneaking 33
+	oncontrols 34
+	issneaking 35
+	isalive 36
+	isbspmodel 37
+	reflectgauss 38
+	hastarget 39
+	isinworld 40
+	isplayer 41
+	isnetclient 42
+	teamid 43
+	ns_resetentity 45
+	getnexttarget 46
+	think 47
+	touch 48
+	use 49
+	blocked 50
+	ns_updateonremove 51
+	respawn 52
+	updateowner 53
+	fbecomeprone 54
+	center 55
+	eyeposition 56
+	earposition 57
+	bodytarget 58
+	illumination 59
+	fvisible 60
+	fvecvisible 61
+@end
+
+@section ts linux
+	pev 0
+	base 0x60
+	
+	ts_breakablerespawn 2
+	ts_canusedthroughwalls 3
+	ts_respawnwait 4
+	spawn 5
+	precache 6
+	keyvalue 7
+	objectcaps 10
+	activate 11
+	setobjectcollisionbox 12
+	classify 13
+	deathnotice 14
+	traceattack 15
+	takedamage 16
+	takehealth 17
+	killed 18
+	bloodcolor 19
+	tracebleed 20
+	istriggered 21
+	gettogglestate 24
+	addpoints 25
+	addpointstoteam 26
+	addplayeritem 27
+	removeplayeritem 28
+	giveammo 29
+	getdelay 30
+	ismoving 31
+	overridereset 32
+	damagedecal 33
+	settogglestate 34
+	startsneaking 35
+	stopsneaking 36
+	oncontrols 37
+	issneaking 38
+	isalive 39
+	isbspmodel 40
+	reflectgauss 41
+	hastarget 42
+	isinworld 43
+	isplayer 44
+	isnetclient 45
+	teamid 46
+	getnexttarget 47
+	think 48
+	touch 49
+	use 50
+	blocked 51
+	respawn 52
+	updateowner 53
+	fbecomeprone 54
+	center 55
+	eyeposition 56
+	earposition 57
+	bodytarget 58
+	illumination 59
+	fvisible 60
+	fvecvisible 61
+@end
+@section ts windows
+	pev 4
+	base 0x0
+	
+	ts_breakablerespawn 0
+	ts_canusedthroughwalls 1
+	ts_respawnwait 2
+	spawn 3
+	precache 4
+	keyvalue 5
+	objectcaps 8
+	activate 9
+	setobjectcollisionbox 10
+	classify 11
+	deathnotice 12
+	traceattack 13
+	takedamage 14
+	takehealth 15
+	killed 16
+	bloodcolor 17
+	tracebleed 18
+	istriggered 19
+	gettogglestate 22
+	addpoints 23
+	addpointstoteam 24
+	addplayeritem 25
+	removeplayeritem 26
+	giveammo 27
+	getdelay 28
+	ismoving 29
+	overridereset 30
+	damagedecal 31
+	settogglestate 32
+	startsneaking 33
+	stopsneaking 34
+	oncontrols 35
+	issneaking 36
+	isalive 37
+	isbspmodel 38
+	reflectgauss 39
+	hastarget 40
+	isinworld 41
+	isplayer 42
+	isnetclient 43
+	teamid 44
+	getnexttarget 45
+	think 46
+	touch 47
+	use 48
+	blocked 49
+	respawn 50
+	updateowner 51
+	fbecomeprone 52
+	center 53
+	eyeposition 54
+	earposition 55
+	bodytarget 56
+	illumination 57
+	fvisible 58
+	fvecvisible 59
+@end
+
+; Sven-Coop has no linux binaries.  This makes disassembly much harder.
+@section svencoop windows
+	pev 4
+	base 0x0
+	
+	takedamage 11
+	use 46
+@end
+
+; ESF also has no linux binaries.
+@section esf windows
+	pev 4
+	base 0x0
+	
+	takedamage 12
+	use 46
+@end
diff --git a/dlls/hamsandwich/config_parser.cpp b/dlls/hamsandwich/config_parser.cpp
new file mode 100644
index 00000000..547dedc4
--- /dev/null
+++ b/dlls/hamsandwich/config_parser.cpp
@@ -0,0 +1,369 @@
+#include "sdk/amxxmodule.h"
+
+#include "ham_const.h"
+#include "hooklist.h"
+#include "offsets.h"
+
+extern hook_t hooklist[];
+
+enum
+{
+	LEX_INVALID = 0,
+
+	LEX_UNKNOWN,
+
+	LEX_START_SEC,
+	LEX_END_SEC,
+
+	LEX_MIRROR,
+
+	LEX_PEV,
+	LEX_BASE,
+
+	LEX_END
+};
+
+const char *tokens[] =
+{
+	"", // LEX_INVALID
+
+	"", // LEX_UNKNOWN
+
+	"@section", // LEX_START_SEC
+	"@end", // LEX_END_SEC
+
+	"@mirror", // LEX_MIRROR
+
+	"pev", // LEX_PEV
+	"base", // LEX_BASE
+
+	"", // LEX_END
+};
+
+static void trim_line(char *input);
+static void read_mirror(char *input);
+static void skip_to_end_of_section(FILE *fp);
+static int lex(char*& buffer);
+
+int lex(char*& buffer)
+{
+	trim_line(buffer);
+
+	size_t len;
+
+	for (int i=0; i<LEX_END; i++)
+	{
+		if (tokens[i]!=NULL && *(tokens[i])!='\0')
+		{
+			len=strlen(tokens[i]);
+			if (strncmp(buffer,tokens[i],len)==0)
+			{
+				buffer+=len+1;
+				return i;
+			}
+		}
+	}
+	return LEX_UNKNOWN;
+}
+
+// How we handle "mirrors"
+// We just note down the current mod name, and every time
+// we come across a mirror with the destination that matches
+// the current mod name, we change the current mod name to
+// the source for that mirror.
+
+char CurrentModName[64];
+
+static void read_mirror(char *input)
+{
+	char *data=input;
+	char *data2;
+
+	char source[64];
+	char dest[64];
+
+	char old;
+	while ( *data!=' ' &&
+			*data!='\t' &&
+			*data!='\0')
+	{
+
+		data++;
+	}
+
+	old=*data;
+	*data='\0';
+
+	// mark down the source
+	snprintf(source, sizeof(source)-1, "%s", input);
+
+	*data=old;
+
+	while ( *data==' ' ||
+			*data=='\t')
+	{
+		data++;
+	}
+	data2=data;
+
+	while ( *data!=' ' &&
+			*data!='\t' &&
+			*data!='\0')
+	{
+		data++;
+	}
+	old=*data;
+	*data='\0';
+
+	snprintf(dest, sizeof(dest)-1, "%s", data2);
+
+	*data=old;
+
+	if (strcmp(dest, CurrentModName)==0)
+	{
+		snprintf(CurrentModName, sizeof(CurrentModName)-1, "%s", dest);
+	}
+
+}
+
+static void trim_line(char *input)
+{
+	char *oldinput=input;
+	char *start=input;
+
+	while ( *start==' ' ||
+			*start=='\t')
+	{
+		start++;
+	}
+
+	// Overwrite the whitespace
+
+	if (start != input)
+	{
+		while ((*input++=*start++)!='\0')
+			/* do nothing */ ;
+	}
+
+	start=oldinput;
+
+	start+=strlen(start) - 1;
+
+	while ( start > oldinput &&
+			( *start == '\0' ||
+			  *start == ' '  ||
+			  *start == '\r' ||
+			  *start == '\n' ||
+			  *start == '\t'))
+	{
+		start--;
+	}
+	start++;
+	*start='\0';
+
+	// Now find any comments and cut off at the start
+
+	while (*start != '\0')
+	{
+		if (*start == ';')
+		{
+			*start='\0';
+			break;
+		}
+
+		start++;
+	}
+}
+
+void skip_to_end_of_section(FILE *fp)
+{
+	char buffer[1024];
+
+	while (!feof(fp))
+	{
+		buffer[0]='\0';
+
+		fgets(buffer, sizeof(buffer)-1, fp);
+
+		trim_line(buffer);
+
+		char *b=&buffer[0];
+		if (lex(b)==LEX_END_SEC)
+		{
+			break;
+		}
+	}
+}
+static const char* get_localinfo( const char* name , const char* def = 0 )
+{
+	const char* b = LOCALINFO( (char*)name );
+	if (((b==0)||(*b==0)) && def )
+		SET_LOCALINFO((char*)name,(char*)(b = def) );
+	return b;
+}
+int read_start_section(char *data)
+{
+	printf("Section: %s\n", data);
+	if (strncmp(data, CurrentModName, strlen(CurrentModName))==0)
+	{
+		data+=strlen(CurrentModName)+1;
+		trim_line(data);
+
+#ifdef _WIN32
+		if (strcmp(data, "windows")==0)
+#elif defined __linux__
+		if (strcmp(data, "linux")==0)
+#endif
+		{
+			return 1;
+		}
+	}
+	return 0;
+}
+int read_number(char *input)
+{
+	char *end; /* Temporary pointer, needed for strtoul(). */
+
+	// if begins with 0x or 0X it's to be interpretted as hex
+	if (*input=='0' && 
+		(*(input+1)=='x' || *(input+1)=='X'))
+	{
+		return strtoul(input,&end,16);
+	}
+
+	// otherwise it's to be interpretted as base 10
+	return strtoul(input,&end,10);
+}
+void process_pev(char *data)
+{
+	trim_line(data);
+	Offsets.SetPev(read_number(data));
+}
+void process_base(char *data)
+{
+	trim_line(data);
+	Offsets.SetBase(read_number(data));
+}
+void process_key(char *data)
+{
+	size_t size=0;
+
+	char *a=data;
+
+	while (*a != ' ' && *a != '\t' && *a != '\0')
+	{
+		a++;
+		size++;
+	}
+
+	int set=0;
+	for (int i=0; i< HAM_LAST_ENTRY_DONT_USE_ME_LOL; i++)
+	{
+		if (strncmp(data, hooklist[i].name, size)==0)
+		{
+			data+=size+1;
+
+			trim_line(data);
+			int value=read_number(data);
+
+			hooklist[i].isset=1;
+			hooklist[i].vtid=value;
+
+			printf("setting \"%s\" to %d", hooklist[i].name, hooklist[i].vtid);
+
+			set=1;
+			break;
+
+		}
+	}
+
+	if (set==0)
+	{
+		printf("stray key in process_key: %s", data);
+	}
+
+}
+int ReadConfig(void)
+{
+	char FileName[512];
+
+	MF_BuildPathnameR(FileName,sizeof(FileName)-1,"%s",get_localinfo("amxx_configsdir","addons/amxmodx/configs"));
+
+	strncat(FileName,"/hamdata.ini",sizeof(FileName)-1);
+
+	FILE *fp=fopen(FileName,"r");
+
+
+	snprintf(CurrentModName, sizeof(CurrentModName)-1, "%s", MF_GetModname());
+
+	if (!fp)
+	{
+		MF_Log("Unable to open \"%s\" for reading.", FileName);
+
+		return -1;
+	}
+
+	char data[2048];
+
+	int insec=0;
+
+	while (!feof(fp))
+	{
+		data[0]='\0';
+
+		fgets(data, sizeof(data)-1, fp);
+
+		char *b=&data[0];
+
+		switch(lex(b))
+		{
+		case LEX_PEV:
+			{
+				if (insec)
+				{
+					process_pev(b);
+				}
+				break;
+			};
+		case LEX_BASE:
+			{
+				if (insec)
+				{
+					process_base(b);
+				}
+				break;
+			};
+		case LEX_MIRROR:
+			{
+				read_mirror(b);
+				break;
+			};
+		case LEX_START_SEC:
+			{
+				insec=read_start_section(b);
+
+				if (!insec)
+				{
+					skip_to_end_of_section(fp);
+				}
+				break;
+			};
+		case LEX_END_SEC:
+			{
+				insec=0;
+				break;
+			};
+		case LEX_UNKNOWN:
+			{
+				if (insec)
+				{
+					process_key(b);
+				}
+			};
+		}
+
+
+	}
+
+	return 1;
+}
diff --git a/dlls/hamsandwich/ecall_funcs.cpp b/dlls/hamsandwich/ecall_funcs.cpp
new file mode 100644
index 00000000..543cf0b2
--- /dev/null
+++ b/dlls/hamsandwich/ecall_funcs.cpp
@@ -0,0 +1,479 @@
+#include "sdk/amxxmodule.h"
+
+#include "offsets.h"
+#include "ham_utils.h"
+#include "hooklist.h"
+
+#include "CVector.h"
+#include "forward.h"
+#include "hook.h"
+
+
+extern CVector<Hook *> hooks[HAM_LAST_ENTRY_DONT_USE_ME_LOL];
+
+void FailPlugin(AMX *amx, int id, int err, const char *reason);
+
+inline void *GetFunction(void *pthis, int id)
+{
+	void **vtbl=GetVTable(pthis, Offsets.GetBase());
+
+	int **ivtbl=(int **)vtbl;
+	void *func=ivtbl[hooklist[id].vtid];
+
+	return func;
+}
+
+#define SETUP(NUMARGS)					\
+	if (((NUMARGS + 2) * sizeof(cell)) > (unsigned)params[0])	\
+	{									\
+		MF_LogError(amx, AMX_ERR_NATIVE, "Bad arg count.  Expected %d, got %d.", NUMARGS + 2, params[0] / sizeof(cell));	\
+		return 0;						\
+	}									\
+	int func=params[1];					\
+	int id=params[2];					\
+	CHECK_FUNCTION(func);				\
+	CHECK_ENTITY(id);					\
+	void *pv=IndexToPrivate(id);
+
+
+cell eCall_Void_Void(AMX *amx, cell *params)
+{
+	SETUP(0);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void*, int)>(GetFunction(pv, func))(pv, 0);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *)>(GetFunction(pv, func))(pv);
+#endif
+	return 1;
+}
+
+cell eCall_Int_Void(AMX *amx, cell *params)
+{
+	SETUP(0);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void*, int)>(GetFunction(pv, func))(pv, 0);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *)>(GetFunction(pv, func))(pv);
+#endif
+}
+
+cell eCall_Void_Entvar(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev1=&(INDEXENT_NEW(id3)->v);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void*, int, entvars_t *)>(GetFunction(pv, func))(pv, 0, ev1);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, entvars_t *)>(GetFunction(pv, func))(pv, ev1);
+#endif
+	return 1;
+}
+
+
+cell eCall_Void_Cbase(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+
+	CHECK_ENTITY(id3);
+
+	void *pv1=(INDEXENT_NEW(id3)->pvPrivateData);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void*, int, void *)>(GetFunction(pv, func))(pv, 0, pv1);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, void *)>(GetFunction(pv, func))(pv, pv1);
+#endif
+	return 1;
+}
+
+cell eCall_Int_Float_Int(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	float f3=amx_ftoc2(*MF_GetAmxAddr(amx, params[3]));
+	int i4=*MF_GetAmxAddr(amx, params[4]);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void*, int, float, int)>(GetFunction(pv, func))(pv, 0, f3, i4);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, float, int)>(GetFunction(pv, func))(pv, f3, i4);
+#endif
+}
+
+	
+cell eCall_Void_Entvar_Int(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	int i4=*MF_GetAmxAddr(amx, params[4]);
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void*, int, entvars_t *, int)>(GetFunction(pv, func))(pv, 0, ev3, i4);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, entvars_t *, int)>(GetFunction(pv, func))(pv, ev3, i4);
+#endif
+	return 1;
+}
+
+
+cell eCall_Int_Cbase(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+
+	CHECK_ENTITY(id3);
+
+	void *pv1=(INDEXENT_NEW(id3)->pvPrivateData);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void*, int, void *)>(GetFunction(pv, func))(pv, 0, pv1);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, void *)>(GetFunction(pv, func))(pv, pv1);
+#endif
+}
+
+cell eCall_Void_Int_Int(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	int i3=*MF_GetAmxAddr(amx, params[3]);
+	int i4=*MF_GetAmxAddr(amx, params[4]);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void*, int, int, int)>(GetFunction(pv, func))(pv, 0, i3, i4);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, int, int)>(GetFunction(pv, func))(pv, i3, i4);
+#endif
+	return 1;
+}
+
+cell eCall_Int_Int_Str_Int(AMX *amx, cell *params)
+{
+	
+	SETUP(3);
+
+	int i3=*MF_GetAmxAddr(amx, params[3]);
+	char *sz4=MF_GetAmxString(amx, params[4], 0, NULL);
+	int i5=*MF_GetAmxAddr(amx, params[5]);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void*, int, int, const char *, int)>(GetFunction(pv, func))(pv, 0, i3, sz4, i5);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, int, const char *, int)>(GetFunction(pv, func))(pv, i3, sz4, i5);
+#endif
+}
+
+cell eCall_Int_Int(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int i3=*MF_GetAmxAddr(amx, params[3]);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void*, int, int)>(GetFunction(pv, func))(pv, 0, i3);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, int)>(GetFunction(pv, func))(pv, i3);
+#endif
+}
+
+cell eCall_Int_Entvar(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void *, int, entvars_t *)>(GetFunction(pv, func))(pv, 0, ev3);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, entvars_t *)>(GetFunction(pv, func))(pv, ev3);
+#endif
+}
+
+cell eCall_Int_Entvar_Entvar_Float_Int(AMX *amx, cell *params)
+{
+	SETUP(4);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	int id4=*MF_GetAmxAddr(amx, params[4]);
+	float f5=amx_ctof2(*MF_GetAmxAddr(amx, params[5]));
+	int i6=*MF_GetAmxAddr(amx, params[6]);
+
+	CHECK_ENTITY(id3);
+	CHECK_ENTITY(id4);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+	entvars_t *ev4=&(INDEXENT_NEW(id4)->v);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void *, int, entvars_t *, entvars_t *, float, int)>(GetFunction(pv, func))(pv, 0, ev3, ev4, f5, i6);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, entvars_t *, entvars_t *, float, int)>(GetFunction(pv, func))(pv, ev3, ev4, f5, i6);
+#endif
+}
+
+cell eCall_Void_Int(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	int i3=*MF_GetAmxAddr(amx, params[3]);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void *, int, int)>(GetFunction(pv, func))(pv, 0, i3);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, int)>(GetFunction(pv, func))(pv, i3);
+#endif
+
+	return 1;
+}
+
+cell eCall_Void_Cbase_Cbase_Int_Float(AMX *amx, cell *params)
+{
+	SETUP(4);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	int id4=*MF_GetAmxAddr(amx, params[4]);
+	int i5=*MF_GetAmxAddr(amx, params[5]);
+	float f6=amx_ctof(*MF_GetAmxAddr(amx, params[6]));
+
+	CHECK_ENTITY(id3);
+	CHECK_ENTITY(id4);
+
+	void *p3=IndexToPrivate(id3);
+	void *p4=IndexToPrivate(id4);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void *, int, void *, void *, int, float)>(GetFunction(pv, func))(pv, 0, p3, p4, i5, f6);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, void *, void *, int, float)>(GetFunction(pv, func))(pv, p3, p4, i5, f6);
+#endif
+
+	return 1;
+}
+
+cell eCall_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, cell *params)
+{
+	SETUP(5);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4]));
+	Vector v5;
+	TraceResult *tr6=reinterpret_cast<TraceResult *>(*MF_GetAmxAddr(amx, params[6]));
+	int i7=*MF_GetAmxAddr(amx, params[7]);
+
+	float *fl5=(float *)MF_GetAmxAddr(amx, params[5]);
+	v5.x=fl5[0];
+	v5.y=fl5[1];
+	v5.z=fl5[2];
+
+	if (tr6==NULL)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Null traceresult provided.");
+
+		return 0;
+	}
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void *, int, entvars_t *, float, Vector, TraceResult *, int)>(GetFunction(pv, func))(pv, 0, ev3, f4, v5, tr6, i7);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, entvars_t *, float, Vector, TraceResult *, int)>(GetFunction(pv, func))(pv, ev3, f4, v5, tr6, i7);
+#endif
+
+	return 1;
+}
+
+cell eCall_Void_Float_Vector_TraceResult_Int(AMX *amx, cell *params)
+{
+	SETUP(4);
+
+	float f3=amx_ctof2(*MF_GetAmxAddr(amx, params[3]));
+	Vector v4;
+	TraceResult *tr5=reinterpret_cast<TraceResult *>(*MF_GetAmxAddr(amx, params[5]));
+	int i6=*MF_GetAmxAddr(amx, params[6]);
+
+	float *fl4=(float *)MF_GetAmxAddr(amx, params[4]);
+	v4.x=fl4[0];
+	v4.y=fl4[1];
+	v4.z=fl4[2];
+
+	if (tr5==NULL)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Null traceresult provided.");
+
+		return 0;
+	}
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void *, int, float, Vector, TraceResult *, int)>(GetFunction(pv, func))(pv, 0, f3, v4, tr5, i6);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, float, Vector, TraceResult *, int)>(GetFunction(pv, func))(pv, f3, v4, tr5, i6);
+#endif
+
+	return 1;
+}
+
+cell eCall_Str_Void(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+#ifdef _WIN32
+	char *v=reinterpret_cast<char *(__fastcall *)(void *, int)>(GetFunction(pv, func))(pv, 0);
+#elif defined __linux__
+	char *v=reinterpret_cast<char *(*)(void *)>(GetFunction(pv, func))(pv);
+#endif
+	return MF_SetAmxString(amx, params[3], v == NULL ? "" : v, *MF_GetAmxAddr(amx, params[4]));
+
+}
+
+cell eCall_Cbase_Void(AMX *amx, cell *params)
+{
+	SETUP(0);
+#ifdef _WIN32
+	void *ret=reinterpret_cast<void *(__fastcall *)(void *, int)>(GetFunction(pv, func))(pv, 0);
+#elif defined __linux__
+	void *ret=reinterpret_cast<void *(*)(void *)>(GetFunction(pv, func))(pv);
+#endif
+	return PrivateToIndex(ret);
+}
+
+cell eCall_Vector_Void(AMX *amx, cell *params)
+{
+	SETUP(1);
+#ifdef _WIN32
+	Vector ret=reinterpret_cast<Vector (__fastcall *)(void *, int)>(GetFunction(pv, func))(pv, 0);
+#elif defined __linux__
+	Vector ret=reinterpret_cast<Vector (*)(void *)>(GetFunction(pv, func))(pv);
+#endif
+	float *out=(float *)MF_GetAmxAddr(amx, params[3]);
+	out[0]=ret.x;
+	out[1]=ret.y;
+	out[2]=ret.z;
+
+	return 1;
+}
+
+cell eCall_Vector_pVector(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	Vector v3;
+	float *fl3=(float *)MF_GetAmxAddr(amx, params[3]);
+	v3.x=fl3[0];
+	v3.y=fl3[1];
+	v3.z=fl3[2];
+
+#ifdef _WIN32
+	Vector ret=reinterpret_cast<Vector (__fastcall *)(void *, int, Vector*)>(GetFunction(pv, func))(pv, 0, &v3);
+#elif defined __linux__
+	Vector ret=reinterpret_cast<Vector (*)(void *, Vector*)>(GetFunction(pv, func))(pv, &v3);
+#endif
+	float *out=(float *)MF_GetAmxAddr(amx, params[4]);
+	out[0]=ret.x;
+	out[1]=ret.y;
+	out[2]=ret.z;
+
+	fl3[0]=v3.x;
+	fl3[1]=v3.y;
+	fl3[2]=v3.z;
+
+	return 1;
+}
+
+cell eCall_Int_pVector(AMX *amx, cell *params)
+{
+	SETUP(1);
+
+	Vector v3;
+	float *fl3=(float *)MF_GetAmxAddr(amx, params[3]);
+	v3.x=fl3[0];
+	v3.y=fl3[1];
+	v3.z=fl3[2];
+
+#ifdef _WIN32
+	int ret=reinterpret_cast<int (__fastcall *)(void *, int, Vector*)>(GetFunction(pv, func))(pv, 0, &v3);
+#elif defined __linux__
+	int ret=reinterpret_cast<int (*)(void *, Vector*)>(GetFunction(pv, func))(pv, &v3);
+#endif
+
+	fl3[0]=v3.x;
+	fl3[1]=v3.y;
+	fl3[2]=v3.z;
+
+	return ret;
+}
+
+cell eCall_Void_Entvar_Float_Float(AMX *amx, cell *params)
+{
+	SETUP(3);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4]));
+	float f5=amx_ctof2(*MF_GetAmxAddr(amx, params[5]));
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+
+#ifdef _WIN32
+	reinterpret_cast<void (__fastcall *)(void *, int, entvars_t *, float, float)>(GetFunction(pv, func))(pv, 0, ev3, f4, f5);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, entvars_t *, float, float)>(GetFunction(pv, func))(pv, ev3, f4, f5);
+#endif
+
+	return 1;
+}
+
+cell eCall_Int_pFloat_pFloat(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	float f3=amx_ctof2(*MF_GetAmxAddr(amx, params[3]));
+	float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4]));
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void *, int, float*, float*)>(GetFunction(pv, func))(pv, 0, &f3, &f4);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, float*, float*)>(GetFunction(pv, func))(pv, &f3, &f4);
+#endif
+
+}
+
+cell eCall_Void_Entvar_Float(AMX *amx, cell *params)
+{
+	SETUP(2);
+
+	int id3=*MF_GetAmxAddr(amx, params[3]);
+	float f4=amx_ctof2(*MF_GetAmxAddr(amx, params[4]));
+
+	CHECK_ENTITY(id3);
+
+	entvars_t *ev3=&(INDEXENT_NEW(id3)->v);
+
+#ifdef _WIN32
+	return reinterpret_cast<int (__fastcall *)(void *, int, entvars_t*, float)>(GetFunction(pv, func))(pv, 0, ev3, f4);
+#elif defined __linux__
+	return reinterpret_cast<int (*)(void *, entvars_t*, float)>(GetFunction(pv, func))(pv, ev3, f4);
+#endif
+}
diff --git a/dlls/hamsandwich/ecall_funcs.h b/dlls/hamsandwich/ecall_funcs.h
new file mode 100644
index 00000000..e7bbfaf3
--- /dev/null
+++ b/dlls/hamsandwich/ecall_funcs.h
@@ -0,0 +1,54 @@
+#ifndef HOOK_ECALL_H
+#define HOOK_ECALL_H
+
+
+int eCall_Void_Void(AMX *amx, cell *params);
+
+int eCall_Int_Void(AMX *amx, cell *params);
+
+int eCall_Void_Entvar(AMX *amx, cell *params);
+
+int eCall_Void_Cbase(AMX *amx, cell *params);
+
+int eCall_Int_Float_Int(AMX *amx, cell *params);
+	
+int eCall_Void_Entvar_Int(AMX *amx, cell *params);
+
+int eCall_Int_Cbase(AMX *amx, cell *params);
+
+int eCall_Void_Int_Int(AMX *amx, cell *params);
+
+int eCall_Int_Int_Str_Int(AMX *amx, cell *params);
+
+int eCall_Int_Int(AMX *amx, cell *params);
+
+int eCall_Int_Entvar(AMX *amx, cell *params);
+
+int eCall_Int_Entvar_Entvar_Float_Int(AMX *amx, cell *params);
+
+int eCall_Void_Int(AMX *amx, cell *params);
+
+int eCall_Void_Cbase_Cbase_Int_Float(AMX *amx, cell *params);
+
+int eCall_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, cell *params);
+
+int eCall_Void_Float_Vector_TraceResult_Int(AMX *amx, cell *params);
+
+int eCall_Str_Void(AMX *amx, cell *params);
+
+int eCall_Cbase_Void(AMX *amx, cell *params);
+
+int eCall_Vector_Void(AMX *amx, cell *params);
+
+int eCall_Vector_pVector(AMX *amx, cell *params);
+
+int eCall_Int_pVector(AMX *amx, cell *params);
+
+int eCall_Void_Entvar_Float_Float(AMX *amx, cell *params);
+
+int eCall_Int_pFloat_pFloat(AMX *amx, cell *params);
+
+int eCall_Void_Entvar_Float(AMX *amx, cell *params);
+
+
+#endif
diff --git a/dlls/hamsandwich/forward.h b/dlls/hamsandwich/forward.h
new file mode 100644
index 00000000..61bf7719
--- /dev/null
+++ b/dlls/hamsandwich/forward.h
@@ -0,0 +1,40 @@
+#include "sdk/amxxmodule.h"
+
+#ifndef FORWARD_H
+#define FORWARD_H
+
+enum fwdstate
+{
+	FSTATE_INVALID = 0,
+	FSTATE_OK,
+	FSTATE_PAUSE,
+	FSTATE_STOP,
+	FSTATE_DESTROY
+};
+
+class Forward
+{
+public:
+	int      id;    // id of the forward
+	fwdstate state;
+	Forward(int id_) : id(id_), state(FSTATE_OK)
+	{
+		/* do nothing */
+	};
+	Forward() : id(-1), state(FSTATE_INVALID)
+	{
+		/* do nothing */
+	}
+	~Forward()
+	{
+		MF_UnregisterSPForward(id);
+	}
+	inline void Set(int i)
+	{
+		state=FSTATE_OK;
+		id=i;
+	};
+
+};
+
+#endif
diff --git a/dlls/hamsandwich/ham_const.h b/dlls/hamsandwich/ham_const.h
new file mode 100644
index 00000000..5cb737b0
--- /dev/null
+++ b/dlls/hamsandwich/ham_const.h
@@ -0,0 +1,113 @@
+#ifndef HAM_CONST_H
+#define HAM_CONST_H
+
+
+enum 
+{
+	HAM_UNSET = 0,
+	HAM_IGNORED,
+	HAM_HANDLED,
+	HAM_OVERRIDE,
+	HAM_SUPERCEDE
+};
+
+enum
+{
+	Ham_Spawn = 0,
+	Ham_Precache,
+	Ham_Keyvalue,
+	Ham_ObjectCaps,
+	Ham_Activate,
+	Ham_SetObjectCollisionBox,
+	Ham_Classify,
+	Ham_DeathNotice,
+	Ham_TraceAttack,
+	Ham_TakeDamage,
+	Ham_TakeHealth,
+	Ham_Killed,
+	Ham_BloodColor,
+	Ham_TraceBleed,
+	Ham_IsTriggered,
+	Ham_GetToggleState,
+	Ham_AddPoints,
+	Ham_AddPointsToTeam,
+	Ham_AddPlayerItem,
+	Ham_RemovePlayerItem,
+	Ham_GiveAmmo,
+	Ham_GetDelay,
+	Ham_IsMoving,
+	Ham_OverrideReset,
+	Ham_DamageDecal,
+	Ham_SetToggleState,
+	Ham_StartSneaking,
+	Ham_StopSneaking,
+	Ham_OnControls,
+	Ham_IsSneaking,
+	Ham_IsAlive,
+	Ham_IsBSPModel,
+	Ham_ReflectGauss,
+	Ham_HasTarget,
+	Ham_IsInWorld,
+	Ham_IsPlayer,
+	Ham_IsNetClient,
+	Ham_TeamId,
+	Ham_GetNextTarget,
+	Ham_Think,
+	Ham_Touch,
+	Ham_Use,
+	Ham_Blocked,
+	Ham_Respawn,
+	Ham_UpdateOwner,
+	Ham_FBecomeProne,
+	Ham_Center,
+	Ham_EyePosition,
+	Ham_EarPosition,
+	Ham_BodyTarget,
+	Ham_Illumination,
+	Ham_FVisible,
+	Ham_FVecVisible,
+
+	Ham_TS_BreakableRespawn,
+	Ham_TS_CanUsedThroughWalls,
+	Ham_TS_RespawnWait,
+
+	Ham_CS_Restart,
+
+	Ham_DOD_RoundRespawn,
+	Ham_DOD_RoundRespawnEnt,
+	Ham_DOD_RoundStore,
+	Ham_DOD_AreaSetIndex,
+	Ham_DOD_AreaSendStatus,
+	Ham_DOD_GetState,
+	Ham_DOD_GetStateEnt,
+
+	Ham_TFC_DbGetItemName,
+	Ham_TFC_EngineerUse,
+	Ham_TFC_Finished,
+	Ham_TFC_EmpExplode,
+	Ham_TFC_CalcEmpDmgRad,
+	Ham_TFC_TakeEmpBlast,
+	Ham_TFC_EmpRemove,
+	Ham_TFC_TakeConcussionBlast,
+	Ham_TFC_Concuss,
+
+	Ham_NS_GetPointValue,
+	Ham_NS_AwardKill,
+	Ham_NS_ResetEntity,
+	Ham_NS_UpdateOnRemove,
+
+
+	HAM_LAST_ENTRY_DONT_USE_ME_LOL
+};
+
+enum 
+{
+	HAM_OK = 0,
+	
+	HAM_INVALID_FUNC,			// The function is not valid
+	HAM_FUNC_NOT_CONFIGURED,	// This function is not configured in hamdata.ini
+	
+	HAM_ERR_END
+};
+
+#endif
diff --git a/dlls/hamsandwich/ham_utils.h b/dlls/hamsandwich/ham_utils.h
new file mode 100644
index 00000000..99492d34
--- /dev/null
+++ b/dlls/hamsandwich/ham_utils.h
@@ -0,0 +1,124 @@
+#ifndef HAM_UTILS_H
+#define HAM_UTILS_H
+
+#include "sdk/amxxmodule.h"
+#include "offsets.h"
+#include "NEW_Util.h"
+
+#define CHECK_FUNCTION(x)																			\
+	if (x < 0 || x > HAM_LAST_ENTRY_DONT_USE_ME_LOL) {												\
+		FailPlugin(amx, x, HAM_INVALID_FUNC, "Function out of bounds.");							\
+		return 0;																					\
+	} else if (hooklist[x].isset == 0) {															\
+		FailPlugin(amx, x, HAM_FUNC_NOT_CONFIGURED, "Function not configured in hamdata.ini");		\
+		return 0;																					\
+	}
+
+
+#define CHECK_ENTITY(x)																	\
+	if (x < 0 || x > gpGlobals->maxEntities) {											\
+		MF_LogError(amx, AMX_ERR_NATIVE, "Entity out of range (%d)", x);				\
+		return 0;																		\
+	} else {																			\
+		if (INDEXENT_NEW(x)->free) {													\
+			MF_LogError(amx, AMX_ERR_NATIVE, "Invalid entity (%d)", x);					\
+			return 0;																	\
+		} else if (INDEXENT_NEW(x)->pvPrivateData == NULL) {							\
+			MF_LogError(amx, AMX_ERR_NATIVE, "Entity has null private data (%d)", x);	\
+			return 0;																	\
+		}																				\
+	}
+
+inline edict_t *PrivateToEdict(const void *pdata)
+{
+
+	if (!pdata)
+	{
+		return NULL;
+	}
+
+	char *ptr=(char*)pdata + Offsets.GetPev();
+	entvars_t *pev=(entvars_t *)ptr;
+
+	if (!pev)
+	{
+		return NULL;
+	}
+	return pev->pContainingEntity;
+};
+
+inline int PrivateToIndex(const void *pdata)
+{
+
+	if (pdata==NULL)
+	{
+		return -1;
+	}
+	char *ptr=(char*)pdata;
+
+	ptr+=Offsets.GetPev();
+
+	entvars_t *pev=*(entvars_t **)ptr;
+
+
+	if (pev==NULL)
+	{
+		return -1;
+	}
+	
+	if (pev->pContainingEntity==NULL)
+	{
+		return -1;
+	}
+
+	return ENTINDEX_NEW(pev->pContainingEntity);
+};
+inline void *IndexToPrivate(int index)
+{
+	return INDEXENT_NEW(index)->pvPrivateData;
+};
+
+inline int EntvarToIndex(entvars_t *pev)
+{
+	if (pev==NULL)
+	{
+		return -1;
+	}
+	
+	if (pev->pContainingEntity==NULL)
+	{
+		return -1;
+	}
+
+	return ENTINDEX_NEW(pev->pContainingEntity);
+};
+
+inline edict_t *EntvarToEdict(entvars_t *pev)
+{
+	if (pev==NULL)
+	{
+		return NULL;
+	}
+	
+	return pev->pContainingEntity;
+};
+inline void **EdictToVTable(edict_t *ent)
+{
+	char *btbl=(char *)ent->pvPrivateData;
+	btbl+=Offsets.GetBase();
+	return *((void ***)btbl);
+};
+
+inline void **GetVTable(void *pthis, int size)
+{
+	return *((void***)(((char*)pthis)+size));
+}
+inline void *GetVTableEntry(void *pthis, int ventry, int size)
+{
+	void **vtbl=GetVTable(pthis, size);
+
+	return vtbl[ventry];
+}
+
+void print_srvconsole(char *fmt, ...);
+#endif
diff --git a/dlls/hamsandwich/hook.h b/dlls/hamsandwich/hook.h
new file mode 100644
index 00000000..c676aa59
--- /dev/null
+++ b/dlls/hamsandwich/hook.h
@@ -0,0 +1,80 @@
+#ifndef HOOK_H
+#define HOOK_H
+
+#include "forward.h"
+#include "Trampolines.h"
+
+// This is just a simple container for data so I only have to add 1 extra 
+// parameter to calls that get trampolined
+
+class Hook
+{
+public:
+	CVector<Forward *> pre;     // pre forwards
+	CVector<Forward *> post;    // post forwards
+	void            *func;    // original function
+	void           **vtable;  // vtable of the original location
+	int              entry;   // vtable entry of the function
+	void            *target;  // target function being called (the hook)
+	int              exec;    // 1 when this hook is in execution
+	int              del;     // 1 if this hook should be destroyed after exec
+	void            *tramp;   // trampoline for this hook
+	char			*ent;     // ent name that's being hooked
+
+	Hook(void **vtable_, int entry_, void *target_, bool voidcall, int paramcount, char *name) :
+		func(NULL), vtable(vtable_), entry(entry_), target(target_), exec(0), del(0), tramp(NULL)
+		{
+			// original function is vtable[entry]
+			// to not make the compiler whine, cast vtable to int **
+			int **ivtable=(int **)vtable;
+			func=(void *)ivtable[entry];
+
+			// now install a trampoline
+			// (int thiscall, int voidcall, int paramcount, void *extraptr)
+			tramp=CreateGenericTrampoline(true, voidcall, paramcount, (void*)this, target);
+
+			// Insert into vtable
+#if defined _WIN32
+			DWORD OldFlags;
+			VirtualProtect(&ivtable[entry],sizeof(int*),PAGE_READWRITE,&OldFlags);
+#elif defined __linux__
+			mprotect(&ivtable[entry],sizeof(int*),PROT_READ|PROT_WRITE);
+#endif
+			ivtable[entry]=(int*)tramp;
+
+			size_t len=strlen(name);
+			ent=new char[len+1];
+
+			snprintf(ent,len+1,"%s",name);
+		};
+
+	~Hook()
+	{
+		// Insert the original function back into the vtable
+		int **ivtable=(int **)vtable;
+
+#if defined _WIN32
+		DWORD OldFlags;
+		VirtualProtect(&ivtable[entry],sizeof(int*),PAGE_READWRITE,&OldFlags);
+#elif defined __linux__
+		mprotect(&ivtable[entry],sizeof(int*),PROT_READ|PROT_WRITE);
+#endif
+
+		ivtable[entry]=(int *)func;
+
+		free(tramp);
+
+		delete[] ent;
+
+		CVector<Forward *>::iterator end=pre.end();
+
+		for (CVector<Forward *>::iterator i=pre.begin();
+			 i!=end;
+			 ++i)
+		{
+			delete (*i);
+		}
+	}
+};
+
+#endif
diff --git a/dlls/hamsandwich/hook_callbacks.cpp b/dlls/hamsandwich/hook_callbacks.cpp
new file mode 100644
index 00000000..24a960c5
--- /dev/null
+++ b/dlls/hamsandwich/hook_callbacks.cpp
@@ -0,0 +1,563 @@
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <extdll.h>
+#include "sdk/amxxmodule.h"
+
+
+
+#include "CVector.h"
+
+#include "hook.h"
+#include "forward.h"
+
+#include "ham_const.h"	
+#include "ham_utils.h"
+
+
+#define PRE_START()														\
+	int result=HAM_UNSET;												\
+	int thisresult=HAM_UNSET;											\
+	int iThis=PrivateToIndex(pthis);									\
+	CVector<Forward*>::iterator end=hook->pre.end();					\
+	for (CVector<Forward*>::iterator i=hook->pre.begin(); i!=end; i++)	\
+	{																	\
+		if ((*i)->state == FSTATE_OK)									\
+		{																\
+			printf("id=%d\n",(*i)->id);									\
+			thisresult=MF_ExecuteForward((*i)->id,iThis
+
+#define PRE_END()									\
+			);										\
+		}											\
+		if (thisresult > result)					\
+		{											\
+			result=thisresult;						\
+		}											\
+	}												\
+	if (result < HAM_SUPERCEDE)						\
+	{
+
+#define POST_START()													\
+	}																	\
+	end=hook->post.end();												\
+	for (CVector<Forward*>::iterator i=hook->post.begin(); i!=end; i++)\
+	{																	\
+		if ((*i)->state == FSTATE_OK)									\
+		{																\
+			MF_ExecuteForward((*i)->id,iThis
+
+#define POST_END()														\
+			);															\
+		}																\
+	}
+
+
+void Hook_Void_Void(Hook *hook, void *pthis)
+{
+	PRE_START()
+	PRE_END()
+
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void*,int)>(hook->func)(pthis,0);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void*)>(hook->func)(pthis);
+#endif
+
+	POST_START()
+	POST_END()
+}
+int Hook_Int_Void(Hook *hook, void *pthis)
+{
+	int ireturn=0;
+
+	PRE_START()
+	PRE_END()
+	
+	
+#if defined _WIN32
+	ireturn=reinterpret_cast<int (__fastcall*)(void*,int)>(hook->func)(pthis,0);
+#elif defined __linux__
+	ireturn=reinterpret_cast<int (*)(void*)>(hook->func)(pthis);
+#endif
+
+	POST_START()
+	POST_END()
+
+	return ireturn;
+}
+
+void Hook_Void_Entvar(Hook *hook, void *pthis, entvars_t *entvar)
+{
+	int iOther=EntvarToIndex(entvar);
+
+	PRE_START()
+		, iOther
+	PRE_END()
+
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void*, int, entvars_t *)>(hook->func)(pthis, 0, entvar);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void*, entvars_t *)>(hook->func)(pthis, entvar);
+#endif
+
+	POST_START()
+		, iOther
+	POST_END()
+
+}
+
+void Hook_Void_Cbase(Hook *hook, void *pthis, void *other)
+{
+	int iOther=PrivateToIndex(other);
+
+	PRE_START()
+		, iOther
+	PRE_END()
+
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void*, int, void *)>(hook->func)(pthis, 0, other);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void*, void *)>(hook->func)(pthis, other);
+#endif
+
+	POST_START()
+		, iOther
+	POST_END()
+
+
+}
+
+int Hook_Int_Float_Int(Hook *hook, void *pthis, float f1, int i1)
+{
+	int ireturn=0;
+	PRE_START()
+		, f1, i1
+	PRE_END()
+
+#if defined _WIN32
+	ireturn=reinterpret_cast<int (__fastcall*)(void*, int, float, int)>(hook->func)(pthis, 0, f1, i1);
+#elif defined __linux__
+	ireturn=reinterpret_cast<int (*)(void*, float, int)>(hook->func)(pthis, f1, i1);
+#endif
+
+	POST_START()
+		, f1, i1
+	POST_END()
+
+	return ireturn;
+
+}
+void Hook_Void_Entvar_Int(Hook *hook, void *pthis, entvars_t *ev1, int i1)
+{
+	int iOther=EntvarToIndex(ev1);
+
+	PRE_START()
+		, iOther, i1
+	PRE_END()
+
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void*, int, entvars_t *, int)>(hook->func)(pthis, 0, ev1, i1);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void*, entvars_t *, int)>(hook->func)(pthis, ev1, i1);
+#endif
+
+	POST_START()
+		, iOther, i1
+	POST_END()
+}
+
+int Hook_Int_Cbase(Hook *hook, void *pthis, void *cb1)
+{
+	int iOther=PrivateToIndex(cb1);
+	int ireturn=0;
+	PRE_START()
+		, iOther
+	PRE_END()
+#if defined _WIN32
+	ireturn=reinterpret_cast<int (__fastcall*)(void*, int, void *)>(hook->func)(pthis, 0, cb1);
+#elif defined __linux__
+	ireturn=reinterpret_cast<int (*)(void*, void *)>(hook->func)(pthis, cb1);
+#endif
+
+	POST_START()
+		, iOther
+	POST_END()
+
+	return ireturn;
+}
+
+void Hook_Void_Int_Int(Hook *hook, void *pthis, int i1, int i2)
+{
+	PRE_START()
+		,i1, i2
+	PRE_END()
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void*, int, int, int)>(hook->func)(pthis, 0, i1, i2);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void*, int, int)>(hook->func)(pthis, i1, i2);
+#endif
+
+	POST_START()
+		,i1, i2
+	POST_END()
+}
+
+int Hook_Int_Int_Str_Int(Hook *hook, void *pthis, int i1, const char *sz1, int i2)
+{
+	int ireturn=0;
+	PRE_START()
+		,i1, sz1, i2
+	PRE_END()
+#if defined _WIN32
+	ireturn=reinterpret_cast<int (__fastcall*)(void*, int, int, const char *, int)>(hook->func)(pthis, 0, i1, sz1, i2);
+#elif defined __linux__
+	ireturn=reinterpret_cast<int (*)(void*, int, const char *, int)>(hook->func)(pthis, i1, sz1, i2);
+#endif
+
+	POST_START()
+		,i1, sz1, i2
+	POST_END()
+
+	return ireturn;
+}
+
+int Hook_Int_Int(Hook *hook, void *pthis, int i1)
+{
+	int ireturn=0;
+	
+	PRE_START()
+		,i1
+	PRE_END()
+
+#if defined _WIN32
+	ireturn=reinterpret_cast<int (__fastcall*)(void*, int, int)>(hook->func)(pthis, 0, i1);
+#elif defined __linux__
+	ireturn=reinterpret_cast<int (*)(void*, int)>(hook->func)(pthis, i1);
+#endif
+
+	POST_START()
+		,i1
+	POST_END()
+
+	return ireturn;
+}
+
+int Hook_Int_Entvar(Hook *hook, void *pthis, entvars_t *ev1)
+{
+	int ireturn=0;
+	int iOther=EntvarToIndex(ev1);
+
+	PRE_START()
+		,iOther
+	PRE_END()
+
+#if defined _WIN32
+	ireturn=reinterpret_cast<int (__fastcall*)(void*, int, entvars_t *)>(hook->func)(pthis, 0, ev1);
+#elif defined __linux__
+	ireturn=reinterpret_cast<int (*)(void*, entvars_t *)>(hook->func)(pthis, ev1);
+#endif
+
+	POST_START()
+		, iOther
+	POST_END()
+
+	return ireturn;
+}
+
+
+
+// Takedamage
+int Hook_Int_Entvar_Entvar_Float_Int(Hook *hook, void *pthis, entvars_t *inflictor, entvars_t *attacker, float damage, int damagebits)
+{
+	int ireturn=0;
+	int iInflictor=EntvarToIndex(inflictor);
+	int iAttacker=EntvarToIndex(attacker);
+	
+
+	PRE_START()
+		,iInflictor, iAttacker, damage, damagebits
+	PRE_END()
+	
+	
+#if defined _WIN32
+	ireturn=reinterpret_cast<int (__fastcall*)(void*, int, entvars_t *, entvars_t *, float, int)>(hook->func)(pthis, 0, inflictor, attacker, damage, damagebits);
+#elif defined __linux__
+	ireturn=reinterpret_cast<int (*)(void*, entvars_t *, entvars_t *, float, int)>(hook->func)(pthis, inflictor, attacker, damage, damagebits);
+#endif
+
+	POST_START()
+		,iInflictor, iAttacker, damage, damagebits
+	POST_END()
+
+	return ireturn;
+}
+
+void Hook_Void_Int(Hook *hook, void *pthis, int i1)
+{
+	PRE_START()
+		, i1
+	PRE_END()
+
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void*, int, int)>(hook->func)(pthis, 0, i1);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void*, int)>(hook->func)(pthis, i1);
+#endif
+
+	POST_START()
+		,i1
+	POST_END()
+
+}
+
+void Hook_Void_Cbase_Cbase_Int_Float(Hook *hook, void *pthis, void *cb1, void *cb2, int i1, float f1)
+{
+	int iCaller=PrivateToIndex(cb1);
+	int iActivator=PrivateToIndex(cb2);
+	
+
+	PRE_START()
+		,iCaller, iActivator, i1, f1
+	PRE_END()
+	
+	
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void*, int, void *, void *, int, float)>(hook->func)(pthis, 0, cb1, cb2, i1, f1);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void*, void *, void *, int, float)>(hook->func)(pthis, cb1, cb2, i1, f1);
+#endif
+
+	POST_START()
+		,iCaller, iActivator, i1, f1
+	POST_END()
+
+}
+
+void Hook_Void_Entvar_Float_Vector_Trace_Int(Hook *hook, void *pthis, entvars_t *ev1, float f1, Vector v1, TraceResult *tr1, int i1)
+{
+	int iev1=EntvarToIndex(ev1);
+	cell cvec[3];
+	cvec[0]=amx_ftoc2(v1.x);
+	cvec[1]=amx_ftoc2(v1.y);
+	cvec[2]=amx_ftoc2(v1.z);
+
+	PRE_START()
+		,iev1, f1, MF_PrepareCellArrayA(cvec, 3, false), tr1, i1
+	PRE_END()
+
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void*, int, entvars_t *, float, Vector, TraceResult *, int)>(hook->func)(pthis, 0, ev1, f1, v1, tr1, i1);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void*, entvars_t *, float, Vector, TraceResult *, int)>(hook->func)(pthis, ev1, f1, v1, tr1, i1);
+#endif
+
+	POST_START()
+		, iev1, f1, MF_PrepareCellArrayA(cvec, 3, false), tr1, i1
+	POST_END()
+}
+
+void Hook_Void_Float_Vector_TraceResult_Int(Hook *hook, void *pthis, float f1, Vector v1, TraceResult *tr1, int i1)
+{
+	cell cvec[3];
+	cvec[0]=amx_ftoc2(v1.x);
+	cvec[1]=amx_ftoc2(v1.y);
+	cvec[2]=amx_ftoc2(v1.z);
+
+	PRE_START()
+		, f1, MF_PrepareCellArrayA(cvec, 3, false), tr1, i1
+	PRE_END()
+
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void*, int, float, Vector, TraceResult *, int)>(hook->func)(pthis, 0, f1, v1, tr1, i1);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void*, float, Vector, TraceResult *, int)>(hook->func)(pthis, f1, v1, tr1, i1);
+#endif
+
+	POST_START()
+		, f1, MF_PrepareCellArrayA(cvec, 3, false), tr1, i1
+	POST_END()
+}
+const char *Hook_Str_Void(Hook *hook, void *pthis)
+{
+	const char *ret=NULL;
+	PRE_START()
+	PRE_END()
+
+#if defined _WIN32
+	ret=reinterpret_cast<const char *(__fastcall*)(void*, int)>(hook->func)(pthis, 0);
+#elif defined __linux__
+	ret=reinterpret_cast<const char *(*)(void*)>(hook->func)(pthis);
+#endif
+
+	POST_START()
+	POST_END()
+
+	return ret;
+
+}
+
+void *Hook_Cbase_Void(Hook *hook, void *pthis)
+{
+	void *ret=NULL;
+	PRE_START()
+	PRE_END()
+
+#if defined _WIN32
+	ret=reinterpret_cast<void *(__fastcall*)(void*, int)>(hook->func)(pthis, 0);
+#elif defined __linux__
+	ret=reinterpret_cast<void *(*)(void*)>(hook->func)(pthis);
+#endif
+
+	POST_START()
+	POST_END()
+
+	return ret;
+
+}
+
+
+Vector Hook_Vector_Void(Hook *hook, void *pthis)
+{
+	Vector ret;
+
+	memset(&ret, 0x0, sizeof(Vector));
+
+	PRE_START()
+	PRE_END()
+
+#if defined _WIN32
+	ret=reinterpret_cast<Vector (__fastcall*)(void*, int)>(hook->func)(pthis, 0);
+#elif defined __linux__
+	ret=reinterpret_cast<Vector (*)(void*)>(hook->func)(pthis);
+#endif
+
+	POST_START()
+	POST_END()
+
+	return ret;
+
+}
+
+Vector Hook_Vector_pVector(Hook *hook, void *pthis, Vector *v1)
+{
+	Vector ret;
+
+	memset(&ret, 0x0, sizeof(Vector));
+
+	cell cv1[3];
+	cv1[0]=amx_ftoc2(v1->x);
+	cv1[1]=amx_ftoc2(v1->y);
+	cv1[2]=amx_ftoc2(v1->z);
+
+	PRE_START()
+		, MF_PrepareCellArrayA(cv1, 3, false)
+	PRE_END()
+
+#if defined _WIN32
+	ret=reinterpret_cast<Vector (__fastcall*)(void*, int, Vector *)>(hook->func)(pthis, 0, v1);
+#elif defined __linux__
+	ret=reinterpret_cast<Vector (*)(void*, Vector *)>(hook->func)(pthis, v1);
+#endif
+
+	POST_START()
+		, MF_PrepareCellArrayA(cv1, 3, false)
+	POST_END()
+
+	return ret;
+
+}
+
+int Hook_Int_pVector(Hook *hook, void *pthis, Vector *v1)
+{
+	int ret=0;
+
+	cell cv1[3];
+
+	cv1[0]=amx_ftoc2(v1->x);
+	cv1[1]=amx_ftoc2(v1->y);
+	cv1[2]=amx_ftoc2(v1->z);
+
+	PRE_START()
+		, MF_PrepareCellArrayA(cv1, 3, false)
+	PRE_END()
+
+#if defined _WIN32
+	ret=reinterpret_cast<int (__fastcall*)(void*, int, Vector *)>(hook->func)(pthis, 0, v1);
+#elif defined __linux__
+	ret=reinterpret_cast<int (*)(void*, Vector *)>(hook->func)(pthis, v1);
+#endif
+
+	POST_START()
+		, MF_PrepareCellArrayA(cv1, 3, false)
+	POST_END()
+
+	return ret;
+
+}
+
+void Hook_Void_Entvar_Float_Float(Hook *hook, void *pthis, entvars_t *ev1, float f1, float f2)
+{
+	cell cev1=EntvarToIndex(ev1);
+
+	PRE_START()
+		, cev1, f1, f2
+	PRE_END()
+
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void *, int, entvars_t *, float, float)>(hook->func)(pthis, 0, ev1, f1, f2);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, entvars_t *, float, float)>(hook->func)(pthis, ev1, f1, f2);
+#endif
+
+	POST_START()
+		, cev1, f1, f2
+	POST_END()
+
+}
+
+int Hook_Int_pFloat_pFloat(Hook *hook, void *pthis, float *f1, float *f2)
+{
+	int ret=0;
+
+	cell cf1=amx_ftoc2(f1 == NULL ? 0.0 : *f1);
+	cell cf2=amx_ftoc2(f2 == NULL ? 0.0 : *f2);
+
+	PRE_START()
+		, cf1, cf2
+	PRE_END()
+
+#if defined _WIN32
+	ret=reinterpret_cast<int (__fastcall*)(void *, int, float *, float *)>(hook->func)(pthis, 0, f1, f2);
+#elif defined __linux__
+	ret=reinterpret_cast<int (*)(void *, float *, float *)>(hook->func)(pthis, f1, f2);
+#endif
+
+	POST_START()
+		, cf1, cf2
+	POST_END()
+
+	return ret;
+}
+
+void Hook_Void_Entvar_Float(Hook *hook, void *pthis, entvars_t *ev1, float f1)
+{
+	cell cev1=EntvarToIndex(ev1);
+
+	PRE_START()
+		, cev1, f1
+	PRE_END()
+
+#if defined _WIN32
+	reinterpret_cast<void (__fastcall*)(void *, int, entvars_t *, float)>(hook->func)(pthis, 0, ev1, f1);
+#elif defined __linux__
+	reinterpret_cast<void (*)(void *, entvars_t *, float)>(hook->func)(pthis, ev1, f1);
+#endif
+
+	POST_START()
+		, cev1, f1
+	POST_END()
+}
+
diff --git a/dlls/hamsandwich/hook_callbacks.h b/dlls/hamsandwich/hook_callbacks.h
new file mode 100644
index 00000000..cc44a025
--- /dev/null
+++ b/dlls/hamsandwich/hook_callbacks.h
@@ -0,0 +1,67 @@
+
+#ifndef HOOK_CALLBACKS_H
+#define HOOK_CALLBACKS_H
+
+
+void Hook_Void_Void(Hook *hook, void *pthis);
+
+int  Hook_Int_Void(Hook *hook, void *pthis);
+
+void Hook_Void_Entvar(Hook *hook, void *pthis, entvars_t *entvar);
+
+void Hook_Void_Cbase(Hook *hook, void *pthis, void *other);
+
+int  Hook_Int_Float_Int(Hook *hook, void *pthis, float f1, int i1);
+	
+void Hook_Void_Entvar_Int(Hook *hook, void *ptis, entvars_t *ev1, int i1);
+
+int  Hook_Int_Cbase(Hook *hook, void *pthis, void *cb1);
+
+void Hook_Void_Int_Int(Hook *hook, void *pthis, int i1, int i2);
+
+int  Hook_Int_Int_Str_Int(Hook *hook, void *pthis, int i1, const char *sz1,
+						  int i2);
+
+int  Hook_Int_Int(Hook *hook, void *pthis, int i1);
+
+int  Hook_Int_Entvar(Hook *hook, void *pthis, entvars_t *ev1);
+
+int  Hook_Int_Entvar_Entvar_Float_Int(Hook *hook, void *pthis, 
+									  entvars_t *inflictor, 
+									  entvars_t *attacker, float damage, 
+									  int damagebits);
+
+void Hook_Void_Int(Hook *hook, void *pthis, int i1);
+
+void Hook_Void_Cbase_Cbase_Int_Float(Hook *hook, void *pthis, void *cb1, 
+									 void *cb2, int i1, float f1);
+
+void Hook_Void_Entvar_Float_Vector_Trace_Int(Hook *hook, void *pthis, 
+											 entvars_t *ev1, float f1, 
+											 Vector v1, TraceResult *tr1, 
+											 int i1);
+
+void Hook_Void_Float_Vector_TraceResult_Int(Hook *hook, void *pthis, float f1,
+											Vector v1, TraceResult *tr1, 
+											int i1);
+
+const char *Hook_Str_Void(Hook *hook, void *pthis);
+
+void *Hook_Cbase_Void(Hook *hook, void *pthis);
+
+Vector Hook_Vector_Void(Hook *hook, void *pthis);
+
+Vector Hook_Vector_pVector(Hook *hook, void *pthis, Vector *v1);
+
+int Hook_Int_pVector(Hook *hook, void *pthis, Vector *v1);
+
+void Hook_Void_Entvar_Float_Float(Hook *hook, void *pthis, entvars_t *ev1, 
+								  float f1, float f2);
+
+int Hook_Int_pFloat_pFloat(Hook *hook, void *pthis, float *f1, 
+						   float *f2);
+
+void Hook_Void_Entvar_Float(Hook *hook, void *pthis, entvars_t *ev1, float f1);
+
+
+#endif
diff --git a/dlls/hamsandwich/hook_create.cpp b/dlls/hamsandwich/hook_create.cpp
new file mode 100644
index 00000000..e3a623ad
--- /dev/null
+++ b/dlls/hamsandwich/hook_create.cpp
@@ -0,0 +1,125 @@
+#include "sdk/amxxmodule.h"
+
+int Create_Void_Void(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_DONE);
+}
+
+int Create_Int_Void(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_DONE);
+}
+
+int Create_Void_Entvar(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE);
+}
+
+
+int Create_Void_Cbase(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE);
+}
+
+int Create_Int_Float_Int(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_FLOAT, FP_CELL, FP_DONE);
+}
+
+	
+int Create_Void_Entvar_Int(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+}
+
+
+int Create_Int_Cbase(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE);
+}
+
+int Create_Void_Int_Int(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+}
+
+int Create_Int_Int_Str_Int(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_STRING, FP_CELL, FP_DONE);
+}
+
+int Create_Int_Int(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE);
+}
+
+int Create_Int_Entvar(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE);
+}
+
+int Create_Int_Entvar_Entvar_Float_Int(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_CELL, FP_FLOAT, FP_CELL, FP_DONE);
+}
+
+int Create_Void_Int(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_DONE);
+}
+
+int Create_Void_Cbase_Cbase_Int_Float(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_CELL, FP_CELL, FP_FLOAT, FP_DONE);
+}
+
+int Create_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_FLOAT, FP_ARRAY, FP_CELL, FP_CELL, FP_DONE);
+}
+
+int Create_Void_Float_Vector_TraceResult_Int(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_FLOAT, FP_ARRAY, FP_CELL, FP_CELL, FP_DONE);
+}
+
+int Create_Str_Void(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_DONE);
+}
+
+int Create_Cbase_Void(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_DONE);
+}
+
+int Create_Vector_Void(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_DONE);
+}
+
+int Create_Vector_pVector(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_ARRAY, FP_DONE);
+}
+
+int Create_Int_pVector(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_ARRAY, FP_DONE);
+}
+
+int Create_Void_Entvar_Float_Float(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_FLOAT, FP_FLOAT, FP_DONE);
+}
+
+int Create_Int_pFloat_pFloat(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_CELL, FP_DONE);
+}
+
+int Create_Void_Entvar_Float(AMX *amx, const char *func)
+{
+	return MF_RegisterSPForwardByName(amx, func, FP_CELL, FP_CELL, FP_FLOAT, FP_DONE);
+}
+
diff --git a/dlls/hamsandwich/hook_create.h b/dlls/hamsandwich/hook_create.h
new file mode 100644
index 00000000..26189700
--- /dev/null
+++ b/dlls/hamsandwich/hook_create.h
@@ -0,0 +1,54 @@
+#ifndef HOOK_CREATE_H
+#define HOOK_CREATE_H
+
+
+int Create_Void_Void(AMX *amx, const char *func);
+
+int Create_Int_Void(AMX *amx, const char *func);
+
+int Create_Void_Entvar(AMX *amx, const char *func);
+
+int Create_Void_Cbase(AMX *amx, const char *func);
+
+int Create_Int_Float_Int(AMX *amx, const char *func);
+	
+int Create_Void_Entvar_Int(AMX *amx, const char *func);
+
+int Create_Int_Cbase(AMX *amx, const char *func);
+
+int Create_Void_Int_Int(AMX *amx, const char *func);
+
+int Create_Int_Int_Str_Int(AMX *amx, const char *func);
+
+int Create_Int_Int(AMX *amx, const char *func);
+
+int Create_Int_Entvar(AMX *amx, const char *func);
+
+int Create_Int_Entvar_Entvar_Float_Int(AMX *amx, const char *func);
+
+int Create_Void_Int(AMX *amx, const char *func);
+
+int Create_Void_Cbase_Cbase_Int_Float(AMX *amx, const char *func);
+
+int Create_Void_Entvar_Float_Vector_Trace_Int(AMX *amx, const char *func);
+
+int Create_Void_Float_Vector_TraceResult_Int(AMX *amx, const char *func);
+
+int Create_Str_Void(AMX *amx, const char *func);
+
+int Create_Cbase_Void(AMX *amx, const char *func);
+
+int Create_Vector_Void(AMX *amx, const char *func);
+
+int Create_Vector_pVector(AMX *amx, const char *func);
+
+int Create_Int_pVector(AMX *amx, const char *func);
+
+int Create_Void_Entvar_Float_Float(AMX *amx, const char *func);
+
+int Create_Int_pFloat_pFloat(AMX *amx, const char *func);
+
+int Create_Void_Entvar_Float(AMX *amx, const char *func);
+
+
+#endif
diff --git a/dlls/hamsandwich/hook_native.cpp b/dlls/hamsandwich/hook_native.cpp
new file mode 100644
index 00000000..d38c8b82
--- /dev/null
+++ b/dlls/hamsandwich/hook_native.cpp
@@ -0,0 +1,267 @@
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <extdll.h>
+#include "sdk/amxxmodule.h"
+
+
+#include "CVector.h"
+
+#include "hook.h"
+#include "forward.h"
+#include "hook_callbacks.h"
+#include "call_funcs.h"
+#include "ecall_funcs.h"
+#include "hook_create.h"
+#include "offsets.h"
+#include "hooklist.h"
+#include "ham_utils.h"
+
+OffsetManager Offsets;
+
+CVector<Hook *> hooks[HAM_LAST_ENTRY_DONT_USE_ME_LOL];
+
+
+#define V(__STUFF__) reinterpret_cast<void *>(Hook_##__STUFF__), Create_##__STUFF__, Call_##__STUFF__, eCall_##__STUFF__
+
+hook_t hooklist[] =
+{
+	{ 0, 0, "spawn",					true, 0,  V(Void_Void) }, // Spawn
+	{ 0, 0, "precache",					true, 0,  V(Void_Void) }, // Precache
+	{ 0, 0, "keyvalue",					true, 1,  V(Void_Int) }, // Keyvalue
+	{ 0, 0, "objectcaps",				false, 0, V(Int_Void) }, // ObjectCaps
+	{ 0, 0, "activate",					true, 0,  V(Void_Void) }, // Activate
+	{ 0, 0, "setobjectcollisionbox",	true, 0,  V(Void_Void) }, // SetObjectCollisionBox
+	{ 0, 0, "classify",					false, 0, V(Int_Void) }, // Classify
+	{ 0, 0, "deathnotice",				true, 1,  V(Void_Entvar) }, // DeathNotice
+	{ 0, 0, "traceattack",				true, 7, V(Void_Entvar_Float_Vector_Trace_Int) }, // TraceAttack
+	{ 0, 0, "takedamage",				false, 4, V(Int_Entvar_Entvar_Float_Int) },  // Takedamage
+	{ 0, 0, "takehealth",				false, 2, V(Int_Float_Int) }, // TakeHealth
+	{ 0, 0, "killed",					true,  2, V(Void_Entvar_Int) }, // Killed
+	{ 0, 0, "bloodcolor",				false, 0, V(Int_Void) }, // BloodColor
+	{ 0, 0, "tracebleed",				true, 6, V(Void_Float_Vector_TraceResult_Int) }, // TraceBleed
+	{ 0, 0, "istriggered",				false, 1, V(Int_Cbase) }, // IsTriggered
+	{ 0, 0, "gettogglestate",			false, 0, V(Int_Void) }, // GetToggleState
+	{ 0, 0, "addpoints",				true, 2,  V(Void_Int_Int) }, // AddPoints
+	{ 0, 0, "addpointstoteam",			true, 2,  V(Void_Int_Int) }, // AddPointsToTeam
+	{ 0, 0, "addplayeritem",			false, 1, V(Int_Cbase) }, // AddPlayerItem
+	{ 0, 0, "removeplayeritem",			false, 1, V(Int_Cbase) }, // RemovePlayerItem
+	{ 0, 0, "giveammo",					false, 3, V(Int_Int_Str_Int) }, // GiveAmmo
+	{ 0, 0, "getdelay",					false, 0, V(Int_Void) }, // GetDelay
+	{ 0, 0, "ismoving",					false, 0, V(Int_Void) }, // IsMoving
+	{ 0, 0, "overridereset",			true, 0,  V(Void_Void) }, // OverrideReset
+	{ 0, 0, "damagedecal",				false, 1, V(Int_Int) }, // DamageDecal
+	{ 0, 0, "settogglestate",			true, 1,  V(Void_Int) }, // SetToggleState
+	{ 0, 0, "startsneaking",			true, 0, V(Void_Void) }, // StartSneaking
+	{ 0, 0, "stopsneaking",				true, 0, V(Void_Void) }, // StopSneaking
+	{ 0, 0, "oncontrols",				false, 1, V(Int_Entvar) }, // OnControls
+	{ 0, 0, "issneaking",				false, 0, V(Int_Void) }, // IsSneaking
+	{ 0, 0, "isalive",					false, 0, V(Int_Void) }, // IsAlive
+	{ 0, 0, "isbspmodel",				false, 0, V(Int_Void) }, // IsBSPModel
+	{ 0, 0, "reflectgauss",				false, 0, V(Int_Void) }, // ReflectGauss
+	{ 0, 0, "hastarget",				false, 1, V(Int_Int) }, // HasTarget
+	{ 0, 0, "isinworld",				false, 0, V(Int_Void) }, // IsInWorld
+	{ 0, 0, "isplayer",					false, 0, V(Int_Void) }, // IsPlayer
+	{ 0, 0, "isnetclient",				false, 0, V(Int_Void) }, // IsNetClient
+	{ 0, 0, "teamid",					false, 0, V(Str_Void) }, // TeamID
+	{ 0, 0, "getnexttarget",			false, 0, V(Cbase_Void) }, // GetNextTarget 
+	{ 0, 0, "think",					true, 0,  V(Void_Void) }, // Think
+	{ 0, 0, "touch",					true, 1,  V(Void_Cbase) }, // Touch
+	{ 0, 0, "use",						true, 4,  V(Void_Cbase_Cbase_Int_Float) }, // Use
+	{ 0, 0, "blocked",					true, 1,  V(Void_Cbase) }, // Blocked
+	{ 0, 0, "respawn",					false, 0, V(Cbase_Void) }, // Respawn TODO: Cbase this
+	{ 0, 0, "updateowner",				true, 0,  V(Void_Void) }, // UpdateOwner
+	{ 0, 0, "fbecomeprone",				false, 0, V(Int_Void) }, // FBecomeProne
+
+
+	// TODO: These
+	{ 0, 0, "center",					false, 0, V(Vector_Void) }, // Center
+	{ 0, 0, "eyeposition",				false, 0, V(Vector_Void) }, // EyePosition
+	{ 0, 0, "earposition",				false, 0, V(Vector_Void) }, // EarPosition
+	{ 0, 0, "bodytarget",				false, 1, V(Vector_pVector) }, // BodyTarget
+	{ 0, 0, "illumination",				false, 0, V(Int_Void) }, // Illumination
+	{ 0, 0, "fvisible",					false, 1, V(Int_Cbase) }, // FVisible
+	{ 0, 0, "fvecvisible",				false, 1, V(Int_pVector) }, // FVecVisible
+	/** Mod specific hooks **/
+
+	/* The Specialists */
+	{ 0, 0, "ts_breakablerespawn",		false, 1, V(Int_Int) },		// TS_BreakableRespawn
+	{ 0, 0, "ts_canusedthroughwalls",	false, 0, V(Int_Void) },		// TS_CanUsedThroughWalls
+	{ 0, 0, "ts_respawnwait",			false, 0, V(Int_Void) },		// TS_RespawnWait
+
+	/* Counter-Strike */
+	{ 0, 0, "cstrike_restart",			true, 0, V(Void_Void) },		// CS_Restart
+
+	/* Day of Defeat */
+	{ 0, 0, "dod_roundrespawn",			true, 0, V(Void_Void) },			// DOD_RoundRespawn
+	{ 0, 0, "dod_roundrespawnent",		true, 0, V(Void_Void) },			// DOD_RoundRespawnEnt
+	{ 0, 0, "dod_roundstore",			true, 0, V(Void_Void) },			// DOD_RoundStore
+	{ 0, 0, "dod_areasetindex",			true, 1, V(Void_Int) },			// DOD_AreaSetIndex
+	{ 0, 0, "dod_areasendstatus",		true, 1, V(Void_Cbase) },			// DOD_AreaSendStatus
+	{ 0, 0, "dod_getstate",				false, 0, V(Int_Void) },		// DOD_GetState
+	{ 0, 0, "dod_getstateent",			false, 1, V(Int_Cbase) },							// DOD_GetStateEnt
+
+	
+	/* Team Fortress Classic */
+	// This next one is just a huge guess
+	{ 0, 0, "tfc_dbgetitemname",		false, 0, V(Str_Void) },							// TFC_DbGetItemName
+	{ 0, 0, "tfc_engineeruse",			false, 1, V(Int_Cbase) },		// TFC_EngineerUse
+	{ 0, 0, "tfc_finished",				true, 0, V(Void_Void) },							// TFC_Finished
+	{ 0, 0, "tfc_empexplode",			true, 3, V(Void_Entvar_Float_Float) },	// TFC_EmpExplode
+	{ 0, 0, "tfc_calcempdmgrad",		false, 2, V(Int_pFloat_pFloat) }, // TFC_CalcEmpDmgRad
+	{ 0, 0, "tfc_takeempblast",			true, 1, V(Void_Entvar) },		// TFC_TakeEmpBlast
+	{ 0, 0, "tfc_empremove",			true, 0, V(Void_Void) },					// TFC_EmpRemove
+	{ 0, 0, "tfc_takeconcussionblast",	true, 2, V(Void_Entvar_Float) },	// TFC_TakeConcussionBlast
+	{ 0, 0, "tfc_concuss",				true, 1, V(Void_Entvar) },		// TFC_Concuss
+
+	/* Natural-Selection */
+	{ 0, 0, "ns_getpointvalue",			false, 0, V(Int_Void) },						// NS_GetPointValue
+	{ 0, 0, "ns_awardkill",				true, 1, V(Void_Entvar) },		// NS_AwardKill
+	{ 0, 0, "ns_resetentity",			true, 0, V(Void_Void) },							// NS_ResetEntity
+	{ 0, 0, "ns_updateonremove",		true, 0, V(Void_Void) },							// NS_UpdateOnRemove
+
+};
+
+
+void FailPlugin(AMX *amx, int id, int err, const char *reason)
+{
+	int fwd=MF_RegisterSPForwardByName(amx, "__fatal_ham_error", FP_CELL, FP_CELL, FP_STRING, FP_DONE);
+
+	MF_ExecuteForward(fwd, id, err, reason);
+
+	MF_UnregisterSPForward(fwd);
+}
+static cell AMX_NATIVE_CALL RegisterHam(AMX *amx, cell *params)
+{
+	// Make sure the function we're requesting is within bounds
+	int func=params[1];
+	int post=params[4];
+
+	CHECK_FUNCTION(func);
+
+	char *function=MF_GetAmxString(amx, params[2], 0, NULL);
+	char *classname=MF_GetAmxString(amx, params[3], 1, NULL);
+	
+	// Check the entity
+
+	// create an entity, assign it the gamedll's class, hook it and destroy it
+	edict_t *Entity=CREATE_ENTITY();
+
+	CALL_GAME_ENTITY(PLID,classname,&Entity->v);
+
+	if (Entity->pvPrivateData == NULL)
+	{
+		REMOVE_ENTITY(Entity);
+
+		MF_LogError(amx, AMX_ERR_NATIVE,"Failed to retrieve classtype for \"%s\", hook for \"%s\" not active.",classname,function);
+
+		return 0;
+	}
+	void **vtable=GetVTable(Entity->pvPrivateData, Offsets.GetBase());
+
+	REMOVE_ENTITY(Entity);
+
+	if (vtable == NULL)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE,"Failed to retrieve vtable for \"%s\", hook for \"%s\" not active.",classname,function);
+
+		return 0;
+	}
+
+	// Verify that the function is valid
+	// Don't fail the plugin if this fails, just emit a normal error
+	int fwd=hooklist[func].makefunc(amx, function);
+
+	printf("\n\n----> FORWARD = %d\n\n\n",fwd);
+	if (fwd == -1)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Function %s not found.", function);
+
+		return 0;
+	}
+
+	// We've passed all tests...
+
+	int **ivtable=(int **)vtable;
+
+	void *vfunction=(void *)ivtable[hooklist[func].vtid];
+
+	// Check the list of this function's hooks, see if the function we have is a hook
+
+	CVector<Hook *>::iterator end=hooks[func].end();
+	for (CVector<Hook *>::iterator i=hooks[func].begin();
+		 i!=end;
+		 ++i)
+	{
+		if ((*i)->tramp == vfunction)
+		{
+			// Yes, this function is hooked
+			if (post)
+			{
+				(*i)->post.push_back(new Forward(fwd));
+			}
+			else
+			{
+				(*i)->pre.push_back(new Forward(fwd));
+			}
+			return 1;
+		}
+	}
+
+	// If we got here, the function is not hooked
+	Hook *hook=new Hook(vtable, hooklist[func].vtid, hooklist[func].targetfunc, hooklist[func].isvoid, hooklist[func].paramcount, classname);
+	hooks[func].push_back(hook);
+
+	if (post)
+	{
+		hook->post.push_back(new Forward(fwd));
+	}
+	else
+	{
+		hook->pre.push_back(new Forward(fwd));
+	}
+
+	return 1;
+}
+static cell AMX_NATIVE_CALL ExecuteHam(AMX *amx, cell *params)
+{
+	int func=params[1];
+
+	CHECK_FUNCTION(func);
+
+	return hooklist[func].call(amx, params);
+}
+static cell AMX_NATIVE_CALL ExecuteHamB(AMX *amx, cell *params)
+{
+	int func=params[1];
+
+	CHECK_FUNCTION(func);
+
+	return hooklist[func].ecall(amx, params);
+}
+
+
+static cell AMX_NATIVE_CALL IsHamValid(AMX *amx, cell *params)
+{
+	int func=params[1];
+
+	if (func >= 0 && 
+		func < HAM_LAST_ENTRY_DONT_USE_ME_LOL &&
+		hooklist[func].isset!=0)
+	{
+		return 1;
+	}
+	return 0;
+}
+
+AMX_NATIVE_INFO RegisterNatives[] =
+{
+	{ "RegisterHam",			RegisterHam },
+	{ "ExecuteHam",				ExecuteHam },
+	{ "ExecuteHamB",			ExecuteHamB },
+	{ "IsHamValid",				IsHamValid },
+
+	{ NULL,						NULL }
+};
diff --git a/dlls/hamsandwich/hooklist.h b/dlls/hamsandwich/hooklist.h
new file mode 100644
index 00000000..c33e5149
--- /dev/null
+++ b/dlls/hamsandwich/hooklist.h
@@ -0,0 +1,19 @@
+#ifndef HOOKLIST_T_H
+#define HOOKLIST_T_H
+
+typedef struct hook_s
+{
+	int isset;								// whether or not this hook is registered with hamdata
+	int vtid;								// vtable index of this function
+	const char *name;						// name used in the keys
+	bool isvoid;							// whether or not the target trampoline uses voids
+	int  paramcount;						// how many parameters are in the func
+	void *targetfunc;						// the target hook
+	int (*makefunc)(AMX *, const char*);	// function that creates forwards
+	int (*call)(AMX *, cell*);				// function to call the vcall
+	int (*ecall)(AMX *, cell*);				// function to ecall the vcall
+} hook_t;
+
+extern hook_t hooklist[];
+
+#endif
diff --git a/dlls/hamsandwich/include/hamsandwich.inc b/dlls/hamsandwich/include/hamsandwich.inc
new file mode 100644
index 00000000..d17c6b04
--- /dev/null
+++ b/dlls/hamsandwich/include/hamsandwich.inc
@@ -0,0 +1,179 @@
+#if defined _hamsandwich_included
+	#endinput
+#endif
+
+#define _hamsandwich_included
+
+enum Ham
+{
+	Ham_Spawn = 0,
+	Ham_Precache,
+	Ham_Keyvalue,
+	Ham_ObjectCaps,
+	Ham_Activate,
+	Ham_SetObjectCollisionBox,
+	Ham_Classify,
+	Ham_DeathNotice,
+	Ham_TraceAttack,
+	Ham_TakeDamage,
+	Ham_TakeHealth,
+	Ham_Killed,
+	Ham_BloodColor,
+	Ham_TraceBleed,
+	Ham_IsTriggered,
+	Ham_GetToggleState,
+	Ham_AddPoints,
+	Ham_AddPointsToTeam,
+	Ham_AddPlayerItem,
+	Ham_RemovePlayerItem,
+	Ham_GiveAmmo,
+	Ham_GetDelay,
+	Ham_IsMoving,
+	Ham_OverrideReset,
+	Ham_DamageDecal,
+	Ham_SetToggleState,
+	Ham_StartSneaking,
+	Ham_StopSneaking,
+	Ham_OnControls,
+	Ham_IsSneaking,
+	Ham_IsAlive,
+	Ham_IsBSPModel,
+	Ham_ReflectGauss,
+	Ham_HasTarget,
+	Ham_IsInWorld,
+	Ham_IsPlayer,
+	Ham_IsNetClient,
+	Ham_TeamId,
+	Ham_GetNextTarget,
+	Ham_Think,
+	Ham_Touch,
+	Ham_Use,
+	Ham_Blocked,
+	Ham_Respawn,
+	Ham_UpdateOwner,
+	Ham_FBecomeProne,
+	Ham_Center,
+	Ham_EyePosition,
+	Ham_EarPosition,
+	Ham_BodyTarget,
+	Ham_Illumination,
+	Ham_FVisible,
+	Ham_FVecVisible,
+
+	Ham_TS_BreakableRespawn,
+	Ham_TS_CanUsedThroughWalls,
+	Ham_TS_RespawnWait,
+
+	Ham_CS_Restart,
+
+	Ham_DOD_RoundRespawn,
+	Ham_DOD_RoundRespawnEnt,
+	Ham_DOD_RoundStore,
+	Ham_DOD_AreaSetIndex,
+	Ham_DOD_AreaSendStatus,
+	Ham_DOD_GetState,
+	Ham_DOD_GetStateEnt,
+
+	Ham_TFC_DbGetItemName,
+	Ham_TFC_EngineerUse,
+	Ham_TFC_Finished,
+	Ham_TFC_EmpExplode,
+	Ham_TFC_CalcEmpDmgRad,
+	Ham_TFC_TakeEmpBlast,
+	Ham_TFC_EmpRemove,
+	Ham_TFC_TakeConcussionBlast,
+	Ham_TFC_Concuss,
+
+	Ham_NS_GetPointValue,
+	Ham_NS_AwardKill,
+	Ham_NS_ResetEntity,
+	Ham_NS_UpdateOnRemove,
+
+
+	HAM_LAST_ENTRY_DONT_USE_ME_LOL
+};
+
+
+/**
+ * Hooks the virtual table for the specified entity class.
+ * An example would be: RegisterHam(Ham_TakeDamage, "player_hurt", "player");
+ * Look at the Ham enum for parameter lists.
+ *
+ * @param function		The function to hook.
+ * @param callback		The forward to call.
+ * @param entity		The entity classname to hook.
+ * @param post			Whether or not to forward this in post.
+ */
+ 
+
+native RegisterHam(Ham:function, const callback[], const entity[], post=0);
+
+/**
+ * Executes the virtual function on the entity.
+ * Look at the Ham enum for parameter lists.
+ *
+ * @param function		The function to call.
+ * @param id			The id of the entity to execute it on.
+ */
+native ExecuteHam(Ham:function, id, any:...);
+
+/**
+ * Executes the virtual function on the entity, this will trigger all hooks on that function.
+ * Be very careful about recursion!
+ * Look at the Ham enum for parameter lists.
+ *
+ * @param function		The function to call.
+ * @param id			The id of the entity to execute it on.
+ */
+native ExecuteHamB(Ham:function, id, any:...);
+
+
+/**
+ * Returns whether or not the function for the specified Ham is valid.
+ * Things that would make it invalid would be bounds (an older module version
+ *  may not have all of the functions), and the function not being found in
+ *  the mod's hamdata.ini file.
+ *
+ * @param function		The function to look up.
+ * @return				true if the function is valid, false otherwise.
+ */
+native bool:IsHamValid(Ham:function);
+
+
+enum HamError
+{
+	HAM_OK = 0,
+	
+	HAM_INVALID_FUNC,			// The function is not valid
+	HAM_FUNC_NOT_CONFIGURED,	// This function is not configured in hamdata.ini
+	
+	HAM_ERR_END
+};
+
+// This is the callback from the module, this handles any fatal errors.
+// This will in turn call the "HamFilter(Ham:id, HamError:err, const reason[])" public, if it exists.
+// Return PLUGIN_HANDLED from within the HamFilter to stop the plugin from failing.
+// Any other return value will fail the plugin.
+// You do not need to have a HamFilter, if there is none, all fatal errors will fail the plugin.
+public __fatal_ham_error(Ham:id, HamError:err, const reason[])
+{
+	
+	new func=get_func_id("HamFilter", -1);
+	new bool:fail=true;
+	
+	if (callfunc_begin_i(func, -1)==1)
+	{
+		callfunc_push_int(_:id);
+		callfunc_push_int(_:err);
+		callfunc_push_str(reason, false);
+		if (callfunc_end()==PLUGIN_HANDLED)
+		{
+			fail=false;
+		}
+	}
+	if (fail)
+	{
+		set_fail_state(reason);
+	}
+	
+}
\ No newline at end of file
diff --git a/dlls/hamsandwich/msvc7/fakemeta.sln b/dlls/hamsandwich/msvc7/fakemeta.sln
new file mode 100644
index 00000000..a2143411
--- /dev/null
+++ b/dlls/hamsandwich/msvc7/fakemeta.sln
@@ -0,0 +1,21 @@
+Microsoft Visual Studio Solution File, Format Version 8.00
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "fakemeta", "fakemeta.vcproj", "{5E393C37-22F2-4CA2-9022-6400DC582447}"
+	ProjectSection(ProjectDependencies) = postProject
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfiguration) = preSolution
+		Debug = Debug
+		Release = Release
+	EndGlobalSection
+	GlobalSection(ProjectConfiguration) = postSolution
+		{5E393C37-22F2-4CA2-9022-6400DC582447}.Debug.ActiveCfg = Debug|Win32
+		{5E393C37-22F2-4CA2-9022-6400DC582447}.Debug.Build.0 = Debug|Win32
+		{5E393C37-22F2-4CA2-9022-6400DC582447}.Release.ActiveCfg = Release|Win32
+		{5E393C37-22F2-4CA2-9022-6400DC582447}.Release.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+	EndGlobalSection
+	GlobalSection(ExtensibilityAddIns) = postSolution
+	EndGlobalSection
+EndGlobal
diff --git a/dlls/hamsandwich/msvc7/fakemeta.vcproj b/dlls/hamsandwich/msvc7/fakemeta.vcproj
new file mode 100644
index 00000000..a9b1be78
--- /dev/null
+++ b/dlls/hamsandwich/msvc7/fakemeta.vcproj
@@ -0,0 +1,245 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="fakemeta"
+	ProjectGUID="{5E393C37-22F2-4CA2-9022-6400DC582447}"
+	RootNamespace="fakemeta"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="Debug"
+			IntermediateDirectory="Debug"
+			ConfigurationType="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\sdk"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;FAKEMETA_EXPORTS"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="5"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/fakemeta_amxx.dll"
+				LinkIncremental="2"
+				GenerateDebugInformation="TRUE"
+				ProgramDatabaseFile="$(OutDir)/fakemeta.pdb"
+				SubSystem="2"
+				ImportLibrary="$(OutDir)/fakemeta.lib"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="Release"
+			IntermediateDirectory="Release"
+			ConfigurationType="2"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\sdk"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;FAKEMETA_EXPORTS"
+				RuntimeLibrary="4"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/fakemeta_amxx.dll"
+				LinkIncremental="1"
+				GenerateDebugInformation="TRUE"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				ImportLibrary="$(OutDir)/fakemeta.lib"
+				TargetMachine="1"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCWebDeploymentTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath="..\fakemeta_amxx.cpp">
+			</File>
+			<File
+				RelativePath="..\fakemeta_amxx.h">
+			</File>
+			<File
+				RelativePath="..\fm_tr.cpp">
+			</File>
+			<File
+				RelativePath="..\fm_tr.h">
+			</File>
+			<File
+				RelativePath="..\fm_tr2.cpp">
+			</File>
+			<File
+				RelativePath="..\misc.cpp">
+			</File>
+			<File
+				RelativePath="..\pdata.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="Engine Funcs"
+			Filter="">
+			<File
+				RelativePath="..\dllfunc.cpp">
+			</File>
+			<File
+				RelativePath="..\dllfunc.h">
+			</File>
+			<File
+				RelativePath="..\engfunc.cpp">
+			</File>
+			<File
+				RelativePath="..\engfunc.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="PEV"
+			Filter="">
+			<File
+				RelativePath="..\pev.cpp">
+			</File>
+			<File
+				RelativePath=".\pev.h">
+				<FileConfiguration
+					Name="Debug|Win32">
+					<Tool
+						Name="VCCustomBuildTool"/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+		<Filter
+			Name="Forwards"
+			Filter="">
+			<File
+				RelativePath="..\forward.cpp">
+			</File>
+			<File
+				RelativePath="..\forward.h">
+			</File>
+			<File
+				RelativePath="..\forwardmacros.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Globals"
+			Filter="">
+			<File
+				RelativePath="..\glb.cpp">
+			</File>
+			<File
+				RelativePath="..\glb.h">
+			</File>
+		</Filter>
+		<Filter
+			Name="Module SDK"
+			Filter="">
+			<File
+				RelativePath="..\sdk\moduleconfig.h">
+			</File>
+			<File
+				RelativePath="..\sdk\svn_version.h">
+			</File>
+			<Filter
+				Name="AMXX STL"
+				Filter="">
+				<File
+					RelativePath="..\sdk\CString.h">
+				</File>
+				<File
+					RelativePath="..\sdk\CVector.h">
+				</File>
+			</Filter>
+			<Filter
+				Name="SDK Base"
+				Filter="">
+				<File
+					RelativePath="..\sdk\amxxmodule.cpp">
+				</File>
+				<File
+					RelativePath="..\sdk\amxxmodule.h">
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Pawn Includes"
+			Filter="">
+			<File
+				RelativePath="..\..\..\plugins\include\fakemeta.inc">
+			</File>
+			<File
+				RelativePath="..\..\..\plugins\include\fakemeta_const.inc">
+			</File>
+			<File
+				RelativePath="..\..\..\plugins\include\fakemeta_stocks.inc">
+			</File>
+			<File
+				RelativePath="..\..\..\plugins\include\hlsdk_const.inc">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/dlls/hamsandwich/msvc8/hamsandwich.sln b/dlls/hamsandwich/msvc8/hamsandwich.sln
new file mode 100644
index 00000000..12459017
--- /dev/null
+++ b/dlls/hamsandwich/msvc8/hamsandwich.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hamsandwich", "hamsandwich.vcproj", "{5E393C37-22F2-4CA2-9022-6400DC582447}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{5E393C37-22F2-4CA2-9022-6400DC582447}.Debug|Win32.ActiveCfg = Debug|Win32
+		{5E393C37-22F2-4CA2-9022-6400DC582447}.Debug|Win32.Build.0 = Debug|Win32
+		{5E393C37-22F2-4CA2-9022-6400DC582447}.Release|Win32.ActiveCfg = Release|Win32
+		{5E393C37-22F2-4CA2-9022-6400DC582447}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/dlls/hamsandwich/msvc8/hamsandwich.vcproj b/dlls/hamsandwich/msvc8/hamsandwich.vcproj
new file mode 100644
index 00000000..9c731541
--- /dev/null
+++ b/dlls/hamsandwich/msvc8/hamsandwich.vcproj
@@ -0,0 +1,305 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="8.00"
+	Name="hamsandwich"
+	ProjectGUID="{5E393C37-22F2-4CA2-9022-6400DC582447}"
+	RootNamespace="hamsandwich"
+	Keyword="Win32Proj"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="Debug"
+			IntermediateDirectory="Debug"
+			ConfigurationType="2"
+			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\..\..\..\hlsdk\dlls;..\..\..\..\hlsdk\common;..\..\..\..\hlsdk\engine\;..\..\..\..\hlsdk\pm_shared; ..\..\..\metamod\metamod"
+				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				RuntimeTypeInfo="false"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/hamsandwich_amxx.dll"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				ProgramDatabaseFile="$(OutDir)/hamsandwich.pdb"
+				SubSystem="2"
+				ImportLibrary="$(OutDir)/hamsandwich.lib"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="Release"
+			IntermediateDirectory="Release"
+			ConfigurationType="2"
+			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="..\sdk"
+				PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL"
+				RuntimeLibrary="0"
+				RuntimeTypeInfo="false"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				OutputFile="$(OutDir)/hamsandwich_amxx.dll"
+				LinkIncremental="1"
+				GenerateDebugInformation="true"
+				SubSystem="2"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				ImportLibrary="$(OutDir)/hamsandwich.lib"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCWebDeploymentTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Hooks"
+			>
+			<File
+				RelativePath="..\call_funcs.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\call_funcs.h"
+				>
+			</File>
+			<File
+				RelativePath="..\ecall_funcs.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\ecall_funcs.h"
+				>
+			</File>
+			<File
+				RelativePath="..\forward.h"
+				>
+			</File>
+			<File
+				RelativePath="..\hook.h"
+				>
+			</File>
+			<File
+				RelativePath="..\hook_callbacks.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\hook_callbacks.h"
+				>
+			</File>
+			<File
+				RelativePath="..\hook_create.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\hook_create.h"
+				>
+			</File>
+			<File
+				RelativePath="..\hook_native.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\hooklist.h"
+				>
+			</File>
+			<File
+				RelativePath="..\typetocell.h"
+				>
+			</File>
+			<Filter
+				Name="Trampolines"
+				>
+				<File
+					RelativePath="..\Trampolines.h"
+					>
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="sdk"
+			>
+			<File
+				RelativePath="..\sdk\amxxmodule.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\sdk\amxxmodule.h"
+				>
+			</File>
+			<File
+				RelativePath="..\sdk\moduleconfig.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Calls"
+			>
+		</Filter>
+		<Filter
+			Name="Config File"
+			>
+			<File
+				RelativePath="..\config_parser.cpp"
+				>
+			</File>
+		</Filter>
+		<File
+			RelativePath="..\amxx_api.cpp"
+			>
+		</File>
+		<File
+			RelativePath="..\ham_const.h"
+			>
+		</File>
+		<File
+			RelativePath="..\ham_utils.h"
+			>
+		</File>
+		<File
+			RelativePath="..\NEW_Util.h"
+			>
+		</File>
+		<File
+			RelativePath="..\offsets.h"
+			>
+		</File>
+		<File
+			RelativePath="..\srvcmd.cpp"
+			>
+		</File>
+		<File
+			RelativePath="..\vfuncs.h"
+			>
+		</File>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/dlls/hamsandwich/offsets.h b/dlls/hamsandwich/offsets.h
new file mode 100644
index 00000000..98aec275
--- /dev/null
+++ b/dlls/hamsandwich/offsets.h
@@ -0,0 +1,55 @@
+#ifndef OFFSETS_H
+#define OFFSETS_H
+
+#include "ham_const.h"
+
+// Just a singleton class that keeps pev/base/offset values managed.
+
+class OffsetManager
+{
+private:
+	size_t pev;
+	size_t baseclass;
+	int baseset;
+	int pevset;
+
+public:
+	OffsetManager()
+	{
+		memset(this,0x0,sizeof(*this));
+	}
+	void SetPev(size_t value)
+	{
+		pevset=1;
+		pev=value;
+	};
+	size_t GetPev(void)
+	{
+		return pev;
+	};
+	int IsPevSet()
+	{
+		return pevset;
+	};
+	int IsBaseSet()
+	{
+		return baseset;
+	};
+	void SetBase(size_t value)
+	{
+		baseset=1;
+		baseclass=value;
+	};
+	size_t GetBase(void)
+	{
+		return baseclass;
+	};
+	bool IsValid()
+	{
+		return pevset != 0 && baseset != 0;
+	}
+};
+
+extern OffsetManager Offsets;
+
+#endif
diff --git a/dlls/hamsandwich/sdk/amxxmodule.cpp b/dlls/hamsandwich/sdk/amxxmodule.cpp
new file mode 100644
index 00000000..83067916
--- /dev/null
+++ b/dlls/hamsandwich/sdk/amxxmodule.cpp
@@ -0,0 +1,3119 @@
+/* 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 *************/
+
+// *** 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
+	MODULE_LOGTAG,
+	MODULE_LIBRARY,
+	MODULE_LIBCLASS
+};
+
+// Storage for the requested functions
+PFN_ADD_NATIVES				g_fn_AddNatives;
+PFN_BUILD_PATHNAME			g_fn_BuildPathname;
+PFN_BUILD_PATHNAME_R		g_fn_BuildPathnameR;
+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;
+#ifdef MEMORY_TEST
+PFN_ALLOCATOR				g_fn_Allocator;
+PFN_REALLOCATOR				g_fn_Reallocator;
+PFN_DEALLOCATOR				g_fn_Deallocator;
+#endif
+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;
+PFN_REGISTERFUNCTION		g_fn_RegisterFunction;
+PFN_REQ_FNPTR				g_fn_RequestFunction;
+PFN_AMX_PUSH				g_fn_AmxPush;
+PFN_SET_TEAM_INFO			g_fn_SetTeamInfo;
+PFN_PLAYER_PROP_ADDR		g_fn_PlayerPropAddr;
+PFN_REG_AUTH_FUNC			g_fn_RegAuthFunc;
+PFN_UNREG_AUTH_FUNC			g_fn_UnregAuthFunc;
+PFN_FINDLIBRARY				g_fn_FindLibrary;
+PFN_ADDLIBRARIES			g_fn_AddLibraries;
+PFN_REMOVELIBRARIES			g_fn_RemoveLibraries;
+PFN_OVERRIDENATIVES			g_fn_OverrideNatives;
+PFN_GETLOCALINFO			g_fn_GetLocalInfo;
+
+// *** 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;
+
+	g_fn_RequestFunction = reqFnptrFunc;
+
+	// Req all known functions
+	// Misc
+	REQFUNC("BuildPathname", g_fn_BuildPathname, PFN_BUILD_PATHNAME);
+	REQFUNC("BuildPathnameR", g_fn_BuildPathnameR, PFN_BUILD_PATHNAME_R);
+	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);
+	REQFUNC("RegisterFunction", g_fn_RegisterFunction, PFN_REGISTERFUNCTION);
+
+	// 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);
+	REQFUNC("amx_Push", g_fn_AmxPush, PFN_AMX_PUSH);
+	REQFUNC("SetPlayerTeamInfo", g_fn_SetTeamInfo, PFN_SET_TEAM_INFO);
+	REQFUNC("PlayerPropAddr", g_fn_PlayerPropAddr, PFN_PLAYER_PROP_ADDR);
+	REQFUNC("RegAuthFunc", g_fn_RegAuthFunc, PFN_REG_AUTH_FUNC);
+	REQFUNC("UnregAuthFunc", g_fn_UnregAuthFunc, PFN_UNREG_AUTH_FUNC);
+
+	REQFUNC("FindLibrary", g_fn_FindLibrary, PFN_FINDLIBRARY);
+	REQFUNC("AddLibraries", g_fn_AddLibraries, PFN_ADDLIBRARIES);
+	REQFUNC("RemoveLibraries", g_fn_RemoveLibraries, PFN_REMOVELIBRARIES);
+	REQFUNC("OverrideNatives", g_fn_OverrideNatives, PFN_OVERRIDENATIVES);
+	REQFUNC("GetLocalInfo", g_fn_GetLocalInfo, PFN_GETLOCALINFO);
+
+#ifdef MEMORY_TEST
+	// 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);
+#endif
+
+	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;
+}
+
+C_DLLEXPORT void AMXX_PluginsUnloaded()
+{
+#ifdef FN_AMXX_PLUGINSUNLOADED
+	FN_AMXX_PLUGINSUNLOADED();
+#endif // FN_AMXX_PLUGINSUNLOADED
+}
+
+C_DLLEXPORT void AMXX_PluginsUnloading()
+{
+#ifdef FN_AMXX_PLUGINSUNLOADING
+	FN_AMXX_PLUGINSUNLOADING();
+#endif // FN_AMXX_PLUGINSUNLOADING
+}
+
+// Advanced MF functions
+void MF_Log(const char *fmt, ...)
+{
+	char msg[3072];
+	va_list arglst;
+	va_start(arglst, fmt);
+	vsnprintf(msg, sizeof(msg) - 1, fmt, arglst);
+	va_end(arglst);
+
+	g_fn_Log("[%s] %s", MODULE_LOGTAG, msg);
+}
+
+void MF_LogError(AMX *amx, int err, const char *fmt, ...)
+{
+	char msg[3072];
+	va_list arglst;
+	va_start(arglst, fmt);
+	vsnprintf(msg, sizeof(msg) - 1, fmt, arglst);
+	va_end(arglst);
+
+	g_fn_LogErrorFunc(amx, err, "[%s] %s", MODULE_LOGTAG, msg);
+}
+
+
+#ifdef _DEBUG
+// validate macros
+// Makes sure compiler reports errors when macros are invalid
+void ValidateMacros_DontCallThis_Smiley()
+{
+	MF_BuildPathname("str", "str", 0);
+	MF_BuildPathnameR(NULL, 0, "%d", 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);
+	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");
+	MF_RegisterFunction(NULL, "");
+	MF_SetPlayerTeamInfo(0, 0, "");
+	MF_PlayerPropAddr(0, 0);
+	MF_RegAuthFunc(NULL);
+	MF_UnregAuthFunc(NULL);
+	MF_FindLibrary(NULL, LibType_Class);
+	MF_AddLibraries(NULL, LibType_Class, NULL);
+	MF_RemoveLibraries(NULL);
+	MF_OverrideNatives(NULL, "");
+}
+#endif
+
+#ifdef MEMORY_TEST
+
+/************* 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);
+}
+
+#else
+
+#if !defined NO_ALLOC_OVERRIDES && !defined MEMORY_TEST && !defined WIN32
+void * operator new(size_t size) {
+	return(calloc(1, size)); 
+}
+
+void * operator new[](size_t size) {
+	return(calloc(1, size)); 
+}
+
+void operator delete(void * ptr) {
+	if(ptr)
+		free(ptr);
+}
+
+void operator delete[](void * ptr) {
+	if(ptr)
+		free(ptr);
+}
+#endif
+
+#endif //MEMORY_TEST
+
+/************* 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/hamsandwich/sdk/amxxmodule.h b/dlls/hamsandwich/sdk/amxxmodule.h
new file mode 100644
index 00000000..33e1d9c0
--- /dev/null
+++ b/dlls/hamsandwich/sdk/amxxmodule.h
@@ -0,0 +1,2454 @@
+/*
+ * 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 __attribute__((visibility("default")))
+#define LINUX
+#endif
+
+#undef C_DLLEXPORT
+#define C_DLLEXPORT extern "C" DLLEXPORT
+
+// ***** AMXX stuff *****
+
+// module interface version was 1
+// 2 - added logtag to struct (amxx1.1-rc1)
+// 3 - added new tagAMX structure (amxx1.5)
+// 4 - added new 'library' setting for direct loading
+#define AMXX_INTERFACE_VERSION 4
+
+// amxx module info
+struct amxx_module_info_s
+{
+	const char *name;
+	const char *author;
+	const char *version;
+	int reload;				// reload on mapchange when nonzero
+	const char *logtag;		// added in version 2
+	const char *library;	// added in version 4
+	const char *libclass;	// added in version 4
+};
+
+// 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-2005
+
+#if defined HAVE_STDINT_H
+  #include <stdint.h>
+#else
+  #if defined __LCC__ || defined __DMC__ || defined LINUX
+    #if defined HAVE_INTTYPES_H
+      #include <inttypes.h>
+    #else
+      #include <stdint.h>
+    #endif
+  #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 __MACH__
+      #include <ppc/types.h>
+      typedef unsigned short int  uint16_t;
+      typedef unsigned long int   uint32_t;
+    #elif 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
+  #define HAVE_STDINT_H
+#endif
+#if defined _LP64 || defined WIN64 || defined _WIN64
+  #if !defined __64BIT__
+    #define __64BIT__
+  #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 PAWN_CELL_SIZE
+  #define PAWN_CELL_SIZE 32     /* by default, use 32-bit cells */
+#endif
+#if PAWN_CELL_SIZE==16
+  typedef uint16_t  ucell;
+  typedef int16_t   cell;
+#elif PAWN_CELL_SIZE==32
+  typedef uint32_t  ucell;
+  typedef int32_t   cell;
+#define REAL	float
+#elif PAWN_CELL_SIZE==64
+  typedef uint64_t  ucell;
+  typedef int64_t   cell;
+#define REAL	double
+#else
+  #error Unsupported cell size (PAWN_CELL_SIZE)
+#endif
+
+#define UNPACKEDMAX   ((1 << (sizeof(cell)-1)*8) - 1)
+#define UNLIMITED     (~1u >> 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" */
+
+	#if _MSC_VER >= 1400
+		#if !defined NO_MSVC8_AUTO_COMPAT
+
+			/* Disable deprecation warnings concerning unsafe CRT functions */
+			#if !defined _CRT_SECURE_NO_DEPRECATE
+				#define _CRT_SECURE_NO_DEPRECATE
+			#endif
+
+			/* Replace the POSIX function with ISO C++ conformant ones as they are now deprecated */
+			#define access _access
+			#define cabs _cabs
+			#define cgets _cgets
+			#define chdir _chdir
+			#define chmod _chmod
+			#define chsize _chsize
+			#define close _close
+			#define cprintf _cprintf
+			#define cputs _cputts
+			#define creat _creat
+			#define cscanf _cscanf
+			#define cwait _cwait
+			#define dup _dup
+			#define dup2 _dup2
+			#define ecvt _ecvt
+			#define eof _eof
+			#define execl _execl
+			#define execle _execle
+			#define execlp _execlp
+			#define execlpe _execlpe
+			#define execv _execv
+			#define execve _execv
+			#define execvp _execvp
+			#define execvpe _execvpe
+			#define fcloseall _fcloseall
+			#define fcvt _fcvt
+			#define fdopen _fdopen
+			#define fgetchar _fgetchar
+			#define filelength _filelength
+			#define fileno _fileno
+			#define flushall _flushall
+			#define fputchar _fputchar
+			#define gcvt _gcvt
+			#define getch _getch
+			#define getche _getche
+			#define getcwd _getcwd
+			#define getpid _getpid
+			#define getw _getw
+			#define hypot _hypot
+			#define inp _inp
+			#define inpw _inpw
+			#define isascii __isascii
+			#define isatty _isatty
+			#define iscsym __iscsym
+			#define iscsymf __iscsymf
+			#define itoa _itoa
+			#define j0 _j0
+			#define j1 _j1
+			#define jn _jn
+			#define kbhit _kbhit
+			#define lfind _lfind
+			#define locking _locking
+			#define lsearch _lsearch
+			#define lseek _lseek
+			#define ltoa _ltoa
+			#define memccpy _memccpy
+			#define memicmp _memicmp
+			#define mkdir _mkdir
+			#define mktemp _mktemp
+			#define open _open
+			#define outp _outp
+			#define outpw _outpw
+			#define putch _putch
+			#define putenv _putenv
+			#define putw _putw
+			#define read _read
+			#define rmdir _rmdir
+			#define rmtmp _rmtmp
+			#define setmode _setmode
+			#define sopen _sopen
+			#define spawnl _spawnl
+			#define spawnle _spawnle
+			#define spawnlp _spawnlp
+			#define spawnlpe _spawnlpe
+			#define spawnv _spawnv
+			#define spawnve _spawnve
+			#define spawnvp _spawnvp
+			#define spawnvpe _spawnvpe
+			#define strcmpi _strcmpi
+			#define strdup _strdup
+			#define stricmp _stricmp
+			#define strlwr _strlwr
+			#define strnicmp _strnicmp
+			#define strnset _strnset
+			#define strrev _strrev
+			#define strset _strset
+			#define strupr _strupr
+			#define swab _swab
+			#define tell _tell
+			#define tempnam _tempnam
+			#define toascii __toascii
+			#define tzset _tzset
+			#define ultoa _ultoa
+			#define umask _umask
+			#define ungetch _ungetch
+			#define unlink _unlink
+			#define wcsdup _wcsdup
+			#define wcsicmp _wcsicmp
+			#define wcsicoll _wcsicoll
+			#define wcslwr _wcslwr
+			#define wcsnicmp _wcsnicmp
+			#define wcsnset _wcsnset
+			#define wcsrev _wcsrev
+			#define wcsset _wcsset
+			#define wcsupr _wcsupr
+			#define write _write
+			#define y0 _y0
+			#define y1 _y1
+			#define yn _yn
+
+			/* Disable deprecation warnings because MSVC8 seemingly thinks the ISO C++ conformant 
+			 * functions above are deprecated. */
+			#pragma warning (disable:4996)
+				
+		#endif
+	#else
+		#define vsnprintf _vsnprintf
+	#endif
+#endif
+
+
+/* Some compilers do not support the #pragma align, which should be fine. Some
+ * compilers give a warning on unknown #pragmas, which is not so fine...
+ */
+#if (defined SN_TARGET_PS2 || defined __GNUC__) && !defined AMX_NO_ALIGN
+  #define AMX_NO_ALIGN
+#endif
+
+#if defined __GNUC__
+  #define PACKED        __attribute__((packed))
+#else
+  #define PACKED
+#endif
+
+#if !defined AMX_NO_ALIGN
+  #if defined LINUX || defined __FreeBSD__
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+  #elif defined MACOS && defined __MWERKS__
+	#pragma options align=mac68k
+  #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 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() */
+  /* user data */
+  long usertags[AMX_USERNUM] PACKED;
+  //okay userdata[3] in AMX Mod X is for the CPlugin * pointer
+  //we're also gonna set userdata[2] to a special debug structure
+  void _FAR *userdata[AMX_USERNUM] PACKED;
+  /* native functions can raise an error */
+  int error             PACKED;
+  /* passing parameters requires a "count" field */
+  int paramcount;
+  /* 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 */
+} PACKED 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_INVSTATE,     /* invalid state for this access */
+
+  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
+
+#ifdef FN_AMXX_PLUGINSUNLOADING
+void FN_AMXX_PLUGINSUNLOADING(void);
+#endif // FN_AMXX_PLUGINSUNLOADING
+
+#ifdef FN_AMXX_PLUGINSUNLOADED
+void FN_AMXX_PLUGINSUNLOADED(void);
+#endif // FN_AMXX_PLUGINSUNLOADED
+
+// *** Types ***
+typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/);
+
+// ***** 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.
+};
+
+enum PlayerProp
+{
+	Player_Name,		//String
+	Player_Ip,			//String
+	Player_Team,		//String
+	Player_Ingame,		//bool
+	Player_Authorized,	//bool
+	Player_Vgui,		//bool
+	Player_Time,		//float
+	Player_Playtime,	//float
+	Player_MenuExpire,	//float
+	Player_Weapons,		//struct{int,int}[32]
+	Player_CurrentWeapon,	//int
+	Player_TeamID,			//int
+	Player_Deaths,			//int
+	Player_Aiming,			//int
+	Player_Menu,			//int
+	Player_Keys,			//int
+	Player_Flags,			//int[32]
+	Player_Newmenu,			//int
+	Player_NewmenuPage,		//int
+};
+
+enum LibType
+{
+	LibType_Library,
+	LibType_Class
+};
+
+typedef void (*AUTHORIZEFUNC)(int player, const char *authstring);
+
+typedef int				(*PFN_ADD_NATIVES)				(const AMX_NATIVE_INFO * /*list*/);
+typedef char *			(*PFN_BUILD_PATHNAME)			(const char * /*format*/, ...);
+typedef char *			(*PFN_BUILD_PATHNAME_R)			(char * /*buffer*/, size_t /* maxlen */, 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_PLAYER_PROP_ADDR)			(int /*id*/, int /*prop*/);
+
+#ifdef MEMORY_TEST
+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*/ );
+#endif
+typedef int				(*PFN_AMX_EXEC)					(AMX* /*amx*/, cell* /*return val*/, int /*index*/);
+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*/);
+typedef void			(*PFN_REGISTERFUNCTION)			(void * /*pfn*/, const char * /*desc*/);
+typedef	int				(*PFN_AMX_PUSH)					(AMX * /*amx*/, cell /*value*/);
+typedef	int				(*PFN_SET_TEAM_INFO)			(int /*player */, int /*teamid */, const char * /*name */);
+typedef void			(*PFN_REG_AUTH_FUNC)			(AUTHORIZEFUNC);
+typedef void			(*PFN_UNREG_AUTH_FUNC)			(AUTHORIZEFUNC);
+typedef int				(*PFN_FINDLIBRARY)				(const char * /*name*/, LibType /*type*/);
+typedef size_t			(*PFN_ADDLIBRARIES)				(const char * /*name*/, LibType /*type*/, void * /*parent*/);
+typedef size_t			(*PFN_REMOVELIBRARIES)			(void * /*parent*/);
+typedef void			(*PFN_OVERRIDENATIVES)			(AMX_NATIVE_INFO * /*natives*/, const char * /*myname*/);
+typedef const char *	(*PFN_GETLOCALINFO)				(const char * /*name*/, const char * /*def*/);
+typedef int				(*PFN_AMX_REREGISTER)			(AMX * /*amx*/, AMX_NATIVE_INFO * /*list*/, int /*list*/);
+typedef void *			(*PFN_REGISTERFUNCTIONEX)		(void * /*pfn*/, const char * /*desc*/);
+
+extern PFN_ADD_NATIVES				g_fn_AddNatives;
+extern PFN_BUILD_PATHNAME			g_fn_BuildPathname;
+extern PFN_BUILD_PATHNAME_R			g_fn_BuildPathnameR;
+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_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;
+extern PFN_REGISTERFUNCTION			g_fn_RegisterFunction;
+extern PFN_REQ_FNPTR				g_fn_RequestFunction;
+extern PFN_AMX_PUSH					g_fn_AmxPush;
+extern PFN_SET_TEAM_INFO			g_fn_SetTeamInfo;
+extern PFN_PLAYER_PROP_ADDR			g_fn_PlayerPropAddr;
+extern PFN_REG_AUTH_FUNC			g_fn_RegAuthFunc;
+extern PFN_UNREG_AUTH_FUNC			g_fn_UnregAuthFunc;
+extern PFN_FINDLIBRARY				g_fn_FindLibrary;
+extern PFN_ADDLIBRARIES				g_fn_AddLibraries;
+extern PFN_REMOVELIBRARIES			g_fn_RemoveLibraries;
+extern PFN_OVERRIDENATIVES			g_fn_OverrideNatives;
+extern PFN_GETLOCALINFO				g_fn_GetLocalInfo;
+extern PFN_AMX_REREGISTER			g_fn_AmxReRegister;
+extern PFN_REGISTERFUNCTIONEX		g_fn_RegisterFunctionEx;
+
+#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, ...) { }
+char *			MF_BuildPathnameR			(char *buffer, size_t maxlen, const char *fmt, ...) { }
+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, ...) { }
+void			MF_RegisterFunction			(void *pfn, const char *description) { }
+void *			MF_RequestFunction			(const char *description) { }
+int				MF_AmxPush					(AMX *amx, cell *params) { }
+int				MF_AmxExec					(AMX *amx, cell *retval, int idx) { }
+int				MF_SetPlayerTeamInfo		(int id, int teamid, const char *teamname) { }
+void *			MF_PlayerPropAddr			(int id, int prop) { }
+void			MF_RegAuthFunc				(AUTHORIZEFUNC fn) { }
+void			MF_UnregAuthFunc			(AUTHORIZEFUNC fn) { }
+int				MF_FindLibrary				(const char *name, LibType type) { }
+size_t			MF_AddLibraries				(const char *name, LibType type, void *parent) { }
+size_t			MF_RemoveLibraries			(void *parent) { }
+void			MF_OverrideNatives			(AMX_NATIVE_INFO *natives, const char *myname) { }
+const char *	MF_GetLocalInfo				(const char *name, const char *def) { }
+int				MF_AmxReRegister			(AMX *amx, AMX_NATIVE_INFO *list, int number) { return 0; }
+void *			MF_RegisterFunctionEx		(void *pfn, const char *description) { }
+#endif	// MAY_NEVER_BE_DEFINED
+
+#define MF_AddNatives g_fn_AddNatives
+#define MF_BuildPathname g_fn_BuildPathname
+#define MF_BuildPathnameR g_fn_BuildPathnameR
+#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
+#define MF_RegisterFunction g_fn_RegisterFunction
+#define MF_RequestFunction g_fn_RequestFunction
+#define MF_AmxPush g_fn_AmxPush
+#define	MF_SetPlayerTeamInfo g_fn_SetTeamInfo
+#define MF_PlayerPropAddr g_fn_PlayerPropAddr
+#define MF_RegAuthFunc g_fn_RegAuthFunc
+#define MF_UnregAuthFunc g_fn_UnregAuthFunc
+#define MF_FindLibrary g_fn_FindLibrary
+#define MF_AddLibraries g_fn_AddLibraries
+#define MF_RemoveLibraries g_fn_RemoveLibraries
+#define MF_OverrideNatives g_fn_OverrideNatives
+#define MF_GetLocalInfo g_fn_GetLocalInfo
+#define MF_AmxReRegister g_fn_AmxReRegister
+#define MF_RegisterFunctionEx g_fn_RegisterFunctionEx
+
+#ifdef MEMORY_TEST
+/*** 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 //MEMORY_TEST
+
+#endif // #ifndef __AMXXMODULE_H__
diff --git a/dlls/hamsandwich/sdk/moduleconfig.h b/dlls/hamsandwich/sdk/moduleconfig.h
new file mode 100644
index 00000000..b5b044d9
--- /dev/null
+++ b/dlls/hamsandwich/sdk/moduleconfig.h
@@ -0,0 +1,494 @@
+// Configuration
+
+#ifndef __MODULECONFIG_H__
+#define __MODULECONFIG_H__
+
+//#include "svn_version.h"
+
+// Module info
+#define MODULE_NAME "Ham Sandwich"
+#define MODULE_VERSION "1.8"
+#define MODULE_AUTHOR "AMX Mod X Dev Team"
+#define MODULE_URL "http://www.amxmodx.org"
+#define MODULE_LOGTAG "HAMSANDWICH"
+#define MODULE_LIBRARY "hamsandwich"
+#define MODULE_LIBCLASS ""
+// 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
+
+// use memory manager/tester?
+// note that if you use this, you cannot construct/allocate 
+// anything before the module attached (OnAmxxAttach).
+// be careful of default constructors using new/malloc!
+// #define MEMORY_TEST
+
+// Unless you use STL or exceptions, keep this commented.
+// It allows you to compile without libstdc++.so as a dependency
+// #define NO_ALLOC_OVERRIDES
+
+// Uncomment this if you are using MSVC8 or greater and want to fix some of the compatibility issues yourself 
+// #define NO_MSVC8_AUTO_COMPAT
+
+/** 
+ * 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 (unload) */
+//#define FN_AMXX_DETACH OnAmxxDetach
+
+/** All plugins loaded
+ * Do forward functions init here (MF_RegisterForward)
+ */
+#define FN_AMXX_PLUGINSLOADED OnPluginsLoaded
+
+/** All plugins are about to be unloaded */
+//#define FN_AMXX_PLUGINSUNLOADING OnPluginsUnloading
+
+/** All plugins are now unloaded */
+//#define FN_AMXX_PLUGINSUNLOADED OnPluginsUnloaded
+
+
+/**** 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				FMH_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__
diff --git a/dlls/hamsandwich/srvcmd.cpp b/dlls/hamsandwich/srvcmd.cpp
new file mode 100644
index 00000000..bd75d7c6
--- /dev/null
+++ b/dlls/hamsandwich/srvcmd.cpp
@@ -0,0 +1,100 @@
+#include "sdk/amxxmodule.h"
+
+#include <stdarg.h>
+
+#include "CVector.h"
+
+#include "ham_const.h"
+#include "hooklist.h"
+#include "offsets.h"
+#include "forward.h"
+#include "hook.h"
+
+
+extern hook_t hooklist[];
+extern CVector<Hook *> hooks[HAM_LAST_ENTRY_DONT_USE_ME_LOL];
+
+void print_srvconsole(char *fmt, ...)
+{
+	va_list argptr;
+	static char string[384];
+	va_start(argptr, fmt);
+	vsnprintf(string, sizeof(string) - 1, fmt, argptr);
+	string[sizeof(string) - 1] = '\0';
+	va_end(argptr);
+	
+	SERVER_PRINT(string);
+}
+
+
+
+void HamCommand(void)
+{
+	const char *cmd=CMD_ARGV(1);
+
+	if (strcmp(cmd, "list")==0)
+	{
+		unsigned int Total=0;
+		print_srvconsole("%-24s | %3s | %10s\n","Name","Set","Value");
+		print_srvconsole("-------------------------------------------\n");
+		print_srvconsole("%-24s |  %s  | %10d\n", "pev", Offsets.IsPevSet() == 0 ? "n" : "y", Offsets.GetPev());
+		print_srvconsole("%-24s |  %s  | %10d\n", "base", Offsets.IsBaseSet() == 0 ? "n" : "y", Offsets.GetBase());
+		int count=0;
+		for (int i=0; i<HAM_LAST_ENTRY_DONT_USE_ME_LOL; i++)
+		{
+			print_srvconsole("%-24s |  %s  | %10d\n", hooklist[i].name, hooklist[i].isset == 0 ? "n" : "y", hooklist[i].vtid);
+
+			if (hooklist[i].isset != 0)
+			{
+				Total++;
+			}
+			count++;
+
+			if (count >= 5)
+			{
+				count = 0;
+				print_srvconsole("-------------------------------------------\n");
+
+			}
+
+
+		}
+		print_srvconsole("\n%u keys, %u set.\n\n", HAM_LAST_ENTRY_DONT_USE_ME_LOL, Total);
+		return;
+	}
+	else if (strcmp(cmd, "hooks")==0)
+	{
+		print_srvconsole("%-24s | %-32s | %10s | %10s\n", "Key", "Classname", "Pre", "Post");
+		print_srvconsole("-------------------------------------------------------------------------------------\n");
+		unsigned int ForwardCount=0;
+		unsigned int HookCount=0;
+		int count = 0;
+		for (int i=0; i<HAM_LAST_ENTRY_DONT_USE_ME_LOL; i++)
+		{
+			CVector<Hook *>::iterator end=hooks[i].end();
+
+			for (CVector<Hook *>::iterator j=hooks[i].begin();
+				 j!=end;
+				 ++j)
+			{
+				HookCount++;
+				ForwardCount+=(*j)->pre.size() + (*j)->post.size();
+
+				print_srvconsole("%-24s | %-32s | %10d | %10d\n",hooklist[i].name, (*j)->ent, (*j)->pre.size(), (*j)->post.size());
+				if (count >= 5)
+				{
+					print_srvconsole("-------------------------------------------------------------------------------------\n");
+				}
+			}
+		}
+		print_srvconsole("\n%u active hooks, %u active forwards.\n\n", HookCount, ForwardCount);
+		return;
+	}
+
+	// Unknown command
+	print_srvconsole("Usage: ham < command > [ argument ]\n");
+	print_srvconsole("Commands:\n");
+	print_srvconsole("   %-22s - %s\n", "list", "list all keys and their values from the config file.");
+	print_srvconsole("   %-22s - %s\n", "hooks", "list all active hooks");
+}
+
diff --git a/dlls/hamsandwich/typetocell.h b/dlls/hamsandwich/typetocell.h
new file mode 100644
index 00000000..5087ed64
--- /dev/null
+++ b/dlls/hamsandwich/typetocell.h
@@ -0,0 +1,61 @@
+#ifndef TYPETOCELL_H
+#define TYPETOCELL_H
+
+#include <extdll.h>
+#include "sdk/amxxmodule.h"
+
+#include "CVector.h"
+
+#include "hook.h"
+#include "forward.h"
+
+#include "ham_const.h"	
+#include "ham_utils.h"
+
+
+
+inline cell TypeToCell(const float& value)
+{
+	return amx_ftoc2(value);
+}
+inline cell TypeToCell(const float*& value)
+{
+	return amx_ftoc2(*value);
+}
+
+inline cell TypeToCell(const Vector*& value)
+{
+	return reinterpret_cast<cell>(value);
+}
+inline cell TypeToCell(const int& value)
+{
+	return value;
+}
+
+inline cell TypeToCell(const edict_t*& value)
+{
+	if (value == NULL)
+	{
+		return -1;
+	}
+
+	return ENTINDEX_NEW(value);
+}
+
+inline cell TypeToCell(const entvars_t*& value)
+{
+	if (value == NULL)
+	{
+		return -1;
+	}
+
+	return ENTINDEX_NEW(value->pContainingEntity);
+}
+
+inline cell TypeToCell(const HLBaseEntity*& value)
+{
+	return PrivateToIndex(reinterpret_cast<const void *>(value));
+}
+
+
+#endif