diff --git a/dlls/sqlite/basic_sql.cpp b/dlls/sqlite/basic_sql.cpp
new file mode 100644
index 00000000..9f05cb71
--- /dev/null
+++ b/dlls/sqlite/basic_sql.cpp
@@ -0,0 +1,451 @@
+#include <stdio.h>
+#include "sh_list.h"
+#include "sqlite_header.h"
+#include "sqlheaders.h"
+
+using namespace SourceMod;
+using namespace SourceHook;
+
+SqliteDriver g_Sqlite;
+
+void FreeConnection(void *p, unsigned int num)
+{
+	SQL_Connection *cn = (SQL_Connection *)p;
+
+	free(cn->host);
+	free(cn->user);
+	free(cn->pass);
+	free(cn->db);
+
+	delete cn;
+}
+
+void FreeQuery(void *p, unsigned int num)
+{
+	AmxQueryInfo *qry = (AmxQueryInfo *)p;
+
+	qry->pQuery->FreeHandle();
+	delete qry;
+}
+
+void FreeDatabase(void *p, unsigned int num)
+{
+	IDatabase *db = (IDatabase *)p;
+
+	db->FreeHandle();
+}
+
+static cell AMX_NATIVE_CALL SQL_MakeDbTuple(AMX *amx, cell *params)
+{
+	SQL_Connection *sql = new SQL_Connection;
+	int len;
+
+	char *host =  strdup(MF_GetAmxString(amx, params[1], 0, &len));
+
+	char *p = strchr(host, ':');
+	if (p)
+	{
+		sql->port = atoi(p+1);
+		*p = '\0';
+	} else {
+		sql->port = 0;
+	}
+
+	sql->host = host;
+	sql->user = strdup(MF_GetAmxString(amx, params[2], 0, &len));
+	sql->pass = strdup(MF_GetAmxString(amx, params[3], 0, &len));
+	sql->db = strdup(MF_GetAmxString(amx, params[4], 0, &len));
+
+	unsigned int num = MakeHandle(sql, Handle_Connection, FreeConnection);
+
+	return num;
+}
+
+static cell AMX_NATIVE_CALL SQL_FreeHandle(AMX *amx, cell *params)
+{
+	if (!FreeHandle(params[1]))
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL SQL_Connect(AMX *amx, cell *params)
+{
+	SQL_Connection *sql = (SQL_Connection *)GetHandle(params[1], Handle_Connection);
+	if (!sql)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	DatabaseInfo nfo;
+	nfo.database = sql->db;
+	nfo.user = "";
+	nfo.pass = "";
+	nfo.port = 0;
+	nfo.host = "";
+
+	char buffer[512];
+	int errcode;
+
+	IDatabase *pDb = g_Sqlite.Connect(&nfo, &errcode, buffer, sizeof(buffer)-1);
+
+	if (!pDb)
+	{
+		cell *c_err = MF_GetAmxAddr(amx, params[2]);
+
+		*c_err = errcode;
+		MF_SetAmxString(amx, params[3], buffer, params[4]);
+
+		return 0;
+	}
+
+	return MakeHandle(pDb, Handle_Database, FreeDatabase);
+}
+
+static cell AMX_NATIVE_CALL SQL_PrepareQuery(AMX *amx, cell *params)
+{
+	IDatabase *pDb = (IDatabase *)GetHandle(params[1], Handle_Database);
+	if (!pDb)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	int len;
+	char *fmt = MF_FormatAmxString(amx, params, 2, &len);
+
+	IQuery *pQuery = pDb->PrepareQuery(fmt);
+	if (!pQuery)
+		return 0;
+
+	AmxQueryInfo *qinfo = new AmxQueryInfo;
+	qinfo->pQuery = pQuery;
+
+	memset(&qinfo->info, 0, sizeof(QueryInfo));
+
+	return MakeHandle(qinfo, Handle_Query, FreeQuery);
+}
+
+static cell AMX_NATIVE_CALL SQL_Execute(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	qInfo->error[0] = '\0';
+
+	memset(&qInfo->info, 0, sizeof(QueryInfo));
+
+	if (!qInfo->pQuery->Execute(&qInfo->info, qInfo->error, 254))
+		return 0;
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL SQL_QueryError(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	MF_SetAmxString(amx, params[2], qInfo->error, params[3]);
+
+	return qInfo->info.errorcode;
+}
+
+static cell AMX_NATIVE_CALL SQL_MoreResults(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	if (!qInfo->info.rs)
+		return 0;
+
+	return (qInfo->info.rs->IsDone() ? 0 : 1);
+}
+
+static cell AMX_NATIVE_CALL SQL_IsNull(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	IResultSet *rs = qInfo->info.rs;
+
+	if (!rs || rs->IsDone())
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "No result set in this query!");
+		return 0;
+	}
+
+	unsigned int col = static_cast<unsigned int>(params[2]);
+	if (col >= rs->FieldCount())
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid column: %d", col);
+		return 0;
+	}
+
+	IResultRow *rr = rs->GetRow();
+
+	return rr->IsNull(col) ? 1 : 0;
+}
+
+static cell AMX_NATIVE_CALL SQL_ReadResult(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	IResultSet *rs = qInfo->info.rs;
+
+	if (!rs || rs->IsDone())
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "No result set in this query!");
+		return 0;
+	}
+
+	IResultRow *row = rs->GetRow();
+
+	unsigned int col = static_cast<unsigned int>(params[2]);
+	if (col >= rs->FieldCount())
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid column: %d", col);
+		return 0;
+	}
+
+	cell numparams = params[0] / sizeof(cell);
+	switch (numparams)
+	{
+	case 4:
+		{
+			const char *str = row->GetString(col);
+			if (!str)
+				str = "";
+			cell *len = MF_GetAmxAddr(amx, params[4]);
+			MF_SetAmxString(amx, params[3], str, (int)*len);
+			break;
+		}
+	case 3:
+		{
+			REAL num = row->GetFloat(col);
+			cell *addr = MF_GetAmxAddr(amx, params[3]);
+			*addr = amx_ftoc(num);
+			break;
+		}
+	case 2:
+		{
+			int num = row->GetInt(col);
+			return num;
+			break;
+		}
+	default:
+		{
+			MF_LogError(amx, AMX_ERR_NATIVE, "Bad number of arguments passed.");
+			break;
+		}
+	}
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL SQL_NextRow(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	IResultSet *rs = qInfo->info.rs;
+
+	if (!rs || rs->IsDone())
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "No result set in this query!");
+		return 0;
+	}
+
+	rs->NextRow();
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL SQL_AffectedRows(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	return static_cast<cell>(qInfo->info.affected_rows);
+}
+
+static cell AMX_NATIVE_CALL SQL_NumResults(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	IResultSet *rs = qInfo->info.rs;
+
+	if (!rs)
+	{
+		return 0;
+	}
+
+	return rs->RowCount();
+}
+
+static cell AMX_NATIVE_CALL SQL_NumColumns(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	IResultSet *rs = qInfo->info.rs;
+
+	if (!rs)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "No result set in this query!");
+		return 0;
+	}
+
+	return rs->FieldCount();
+}
+
+static cell AMX_NATIVE_CALL SQL_FieldNumToName(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	IResultSet *rs = qInfo->info.rs;
+
+	if (!rs)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "No result set in this query!");
+		return 0;
+	}
+
+	unsigned int col = static_cast<unsigned int>(params[2]);
+	const char *namewa = rs->FieldNumToName(col);
+
+	if (!namewa)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid column: %d", col);
+		return 0;
+	}
+
+	MF_SetAmxString(amx, params[3], namewa, params[4]);
+
+	return 1;
+}
+
+static cell AMX_NATIVE_CALL SQL_FieldNameToNum(AMX *amx, cell *params)
+{
+	AmxQueryInfo *qInfo = (AmxQueryInfo *)GetHandle(params[1], Handle_Query);
+	if (!qInfo)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	IResultSet *rs = qInfo->info.rs;
+
+	if (!rs)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "No result set in this query!");
+		return 0;
+	}
+
+	int len;
+	char *namewa = MF_GetAmxString(amx, params[2], 0, &len);
+	unsigned int columnId;
+	if (!rs->FieldNameToNum(namewa, &columnId))
+		return -1;
+
+	return columnId;
+}
+
+static cell AMX_NATIVE_CALL SQL_GetAffinity(AMX *amx, cell *params)
+{
+	return MF_SetAmxString(amx, params[1], g_Sqlite.NameString(), params[2]);
+}
+
+static cell AMX_NATIVE_CALL SQL_SetAffinity(AMX *amx, cell *params)
+{
+	int len;
+	char *str = MF_GetAmxString(amx, params[1], 0, &len);
+
+	if (stricmp(str, g_Sqlite.NameString()) == 0)
+	{
+		return 1;
+	}
+
+	SqlFunctions *pFuncs = (SqlFunctions *)MF_RequestFunction(SQL_DRIVER_FUNC);
+	while (pFuncs)
+	{
+		if (pFuncs->driver->IsCompatDriver(str))
+		{
+			return pFuncs->set_affinity(amx);
+		}
+		pFuncs = pFuncs->prev;
+	}
+
+	return 0;
+}
+
+extern AMX_NATIVE_INFO g_BaseSqlNatives[] = 
+{
+	{"SQL_MakeDbTuple",		SQL_MakeDbTuple},
+	{"SQL_FreeHandle",		SQL_FreeHandle},
+	{"SQL_Connect",			SQL_Connect},
+	{"SQL_PrepareQuery",	SQL_PrepareQuery},
+	{"SQL_Execute",			SQL_Execute},
+	{"SQL_QueryError",		SQL_QueryError},
+	{"SQL_MoreResults",		SQL_MoreResults},
+	{"SQL_IsNull",			SQL_IsNull},
+	{"SQL_ReadResult",		SQL_ReadResult},
+	{"SQL_NextRow",			SQL_NextRow},
+	{"SQL_AffectedRows",	SQL_AffectedRows},
+	{"SQL_NumResults",		SQL_NumResults},
+	{"SQL_NumColumns",		SQL_NumColumns},
+	{"SQL_FieldNumToName",	SQL_FieldNumToName},
+	{"SQL_FieldNameToNum",	SQL_FieldNameToNum},
+	{"SQL_GetAffinity",		SQL_GetAffinity},
+	{"SQL_SetAffinity",		SQL_SetAffinity},
+
+	{NULL,					NULL},
+};
+
diff --git a/dlls/sqlite/handles.cpp b/dlls/sqlite/handles.cpp
new file mode 100644
index 00000000..596991b1
--- /dev/null
+++ b/dlls/sqlite/handles.cpp
@@ -0,0 +1,107 @@
+#include <string.h>
+#include "sh_stack.h"
+#include "CVector.h"
+#include "sqlite_header.h"
+
+struct QHandle
+{
+	void *_ptr;
+	FREEHANDLE _func;
+	HandleType type;
+	bool isfree;
+};
+
+CVector<QHandle *> g_Handles;
+CStack<unsigned int> g_FreeHandles;
+
+unsigned int MakeHandle(void *ptr, HandleType type, FREEHANDLE f)
+{
+	unsigned int num;
+	QHandle *h;
+
+	if (g_FreeHandles.size())
+	{
+		num = g_FreeHandles.front();
+		g_FreeHandles.pop();
+		h = g_Handles[num];
+	} else {
+		h = new QHandle;
+		g_Handles.push_back(h);
+		num = static_cast<unsigned int>(g_Handles.size()) - 1;
+	}
+
+	h->_ptr = ptr;
+	h->type = type;
+	h->_func = f;
+	h->isfree = false;
+
+	return num + 1;
+}
+
+void *GetHandle(unsigned int num, HandleType type)
+{
+	if (num == 0)
+		return NULL;
+
+	num--;
+	if (num >= g_Handles.size())
+		return NULL;
+
+	QHandle *h = g_Handles[num];
+	if (h->isfree || (h->type != type))
+		return NULL;
+
+	return h->_ptr;
+}
+
+bool FreeHandle(unsigned int num)
+{
+	if (num == 0)
+		return false;
+
+	unsigned int _num = num;
+
+	num--;
+	if (num >= g_Handles.size())
+		return false;
+
+	QHandle *h = g_Handles[num];
+	if (h->isfree)
+		return false;
+
+	h->_func(h->_ptr, _num);
+	h->_ptr = NULL;
+	h->_func = NULL;
+	h->isfree = true;
+	
+	g_FreeHandles.push(num);
+
+	return true;
+}
+
+void FreeAllHandles(HandleType type)
+{
+	QHandle *q;
+	for (size_t i = 0; i < g_Handles.size(); i++)
+	{
+		q = g_Handles[i];
+		if (q && !q->isfree && q->type == type)
+		{
+			FreeHandle((unsigned int)i);
+		}
+	}
+}
+
+void FreeHandleTable()
+{
+	QHandle *q;
+	for (size_t i = 0; i < g_Handles.size(); i++)
+	{
+		q = g_Handles[i];
+		if (q && !q->isfree)
+			FreeHandle((unsigned int)i);
+	}
+	g_Handles.clear();
+	while (!g_FreeHandles.empty())
+		g_FreeHandles.pop();
+}
diff --git a/dlls/sqlite/module.cpp b/dlls/sqlite/module.cpp
new file mode 100644
index 00000000..fc662764
--- /dev/null
+++ b/dlls/sqlite/module.cpp
@@ -0,0 +1,47 @@
+#include "amxxmodule.h"
+#include "sqlite_header.h"
+#include "sqlheaders.h"
+
+static g_ident = 0;
+
+SqlFunctions g_SqliteFuncs = 
+{
+	&g_Sqlite,
+	SetMysqlAffinity,
+	NULL
+};
+
+int SetMysqlAffinity(AMX *amx)
+{
+	MF_AmxReRegister(amx, g_BaseSqlNatives, -1);
+	MF_AmxReRegister(amx, g_ThreadSqlNatives, -1);
+
+	return 0;
+}
+
+void OnAmxxAttach()
+{
+	MF_AddNatives(g_BaseSqlNatives);
+	MF_AddNatives(g_ThreadSqlNatives);
+	g_SqliteFuncs.prev = (SqlFunctions *)MF_RegisterFunctionEx(&g_SqliteFuncs, SQL_DRIVER_FUNC);
+
+	MF_AddLibraries("dbi", LibType_Class, &g_ident);
+
+	//override any mysqlx old compat stuff
+	MF_AddNatives(g_OldCompatNatives);
+	MF_OverrideNatives(g_OldCompatNatives);
+}
+
+void OnAmxxDetach()
+{
+	ShutdownThreading();
+	MF_RemoveLibraries(&g_ident);
+}
+
+void OnPluginsUnloaded()
+{
+	FreeAllHandles(Handle_OldResult);
+	FreeAllHandles(Handle_OldDb);
+	FreeAllHandles(Handle_Connection);
+}
+
diff --git a/dlls/sqlite/oldcompat_sql.cpp b/dlls/sqlite/oldcompat_sql.cpp
new file mode 100644
index 00000000..b62866bd
--- /dev/null
+++ b/dlls/sqlite/oldcompat_sql.cpp
@@ -0,0 +1,426 @@
+#include <stdio.h>
+#include "sh_list.h"
+#include "sqlite_header.h"
+
+using namespace SourceMod;
+
+struct olddb_s
+{
+	IDatabase *pDatabase;
+	char error[255];
+	int errcode;
+};
+
+struct oldresult_s
+{
+	IQuery *pQuery;
+	QueryInfo info;
+	bool firstCall;
+};
+
+void FreeOldDb(void *ptr, unsigned int hndl)
+{
+	olddb_s *old = (olddb_s *)ptr;
+
+	if (old->pDatabase)
+	{
+		old->pDatabase->FreeHandle();
+		old->pDatabase = NULL;
+	}
+
+	delete old;
+}
+
+void FreeOldResult(void *ptr, unsigned int hndl)
+{
+	oldresult_s *oldres = (oldresult_s *)ptr;
+
+	if (oldres->pQuery)
+	{
+		oldres->pQuery->FreeHandle();
+		oldres->pQuery = NULL;
+	}
+
+	delete oldres;
+}
+
+//native Sql:dbi_connect(_host[], _user[], _pass[], _dbname[], _error[]="", _maxlength=0);
+static cell AMX_NATIVE_CALL dbi_connect(AMX *amx, cell *params)
+{
+	int len;
+	DatabaseInfo info;
+	char *name = MF_GetAmxString(amx, params[4], 3, &len);
+
+	info.host = "";
+	info.user = "";
+	info.pass = "";
+	info.database = name;
+
+	int err;
+	char error[512];
+	IDatabase *pDatabase = g_Sqlite.Connect(&info, &err, error, sizeof(error)-1);
+	if (!pDatabase)
+	{
+		MF_SetAmxString(amx, params[5], error, params[6]);
+		return 0;
+	}
+
+	olddb_s *old = new olddb_s;
+	int hndl;
+
+	old->pDatabase = pDatabase;
+	hndl = MakeHandle(old, Handle_OldDb, FreeOldDb);
+
+	return hndl;
+}
+
+//native Result:dbi_query(Sql:_sql, _query[], {Float,_}:...);
+static cell AMX_NATIVE_CALL dbi_query(AMX *amx, cell *params)
+{
+	olddb_s *old = (olddb_s *)GetHandle(params[1], Handle_OldDb);
+	if (!old)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI handle %d", params[1]);
+		return -1;
+	}
+
+	int len;
+	char *queryString = MF_FormatAmxString(amx, params, 2, &len);
+
+	IQuery *pQuery = old->pDatabase->PrepareQuery(queryString);
+	QueryInfo info;
+
+	old->error[0] = '\0';
+	old->errcode = 0;
+
+	if (!pQuery->Execute(&info, old->error, 254))
+	{
+		old->errcode = info.errorcode;
+		return -1;
+	} else {
+		if (info.rs && info.rs->RowCount())
+		{
+			oldresult_s *oldrs = new oldresult_s;
+			int hndl;
+
+			oldrs->info = info;
+			oldrs->pQuery = pQuery;
+			hndl = MakeHandle(oldrs, Handle_OldResult, FreeOldResult);
+			return hndl;
+		} else {
+			pQuery->FreeHandle();
+			return 0;
+		}
+	}
+
+	/** never reach here */
+	return 0;
+}
+
+//native Result:dbi_query2(Sql:_sql, &rows, _query[], {Float,_}:...);
+static cell AMX_NATIVE_CALL dbi_query2(AMX *amx, cell *params)
+{
+	olddb_s *old = (olddb_s *)GetHandle(params[1], Handle_OldDb);
+	if (!old)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI handle %d", params[1]);
+		return -1;
+	}
+
+	int len;
+	char *queryString = MF_FormatAmxString(amx, params, 3, &len);
+
+	IQuery *pQuery = old->pDatabase->PrepareQuery(queryString);
+	QueryInfo info;
+
+	old->error[0] = '\0';
+	old->errcode = 0;
+
+	if (!pQuery->Execute(&info, old->error, 254))
+	{
+		old->errcode = info.errorcode;
+		return -1;
+	} else {
+		cell *addr = MF_GetAmxAddr(amx, params[2]);
+		*addr = static_cast<cell>(info.affected_rows);
+		if (info.rs && info.rs->RowCount())
+		{
+			oldresult_s *oldrs = new oldresult_s;
+			int hndl;
+
+			oldrs->info = info;
+			oldrs->pQuery = pQuery;
+			oldrs->firstCall = true;
+			hndl = MakeHandle(oldrs, Handle_OldResult, FreeOldResult);
+			return hndl;
+		} else {
+			pQuery->FreeHandle();
+			return 0;
+		}
+	}
+
+	/** never reach here */
+	return 0;
+}
+
+//native dbi_nextrow(Result:_result);
+static cell AMX_NATIVE_CALL dbi_nextrow(AMX *amx, cell *params)
+{
+	oldresult_s *oldrs = (oldresult_s *)GetHandle(params[1], Handle_OldResult);
+	if (!oldrs)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI result handle %d", params[1]);
+		return 0;
+	}
+
+	if (oldrs->firstCall)
+	{
+		oldrs->firstCall = false;
+		return (oldrs->info.rs->IsDone() ? 0 : 1);
+	} else {
+		oldrs->info.rs->NextRow();
+		return (oldrs->info.rs->IsDone() ? 0 : 1);
+	}
+}
+
+//native dbi_field(Result:_result, _fieldnum, {Float,_}:... );
+static cell AMX_NATIVE_CALL dbi_field(AMX *amx, cell *params)
+{
+	oldresult_s *oldrs = (oldresult_s *)GetHandle(params[1], Handle_OldResult);
+	if (!oldrs)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI result handle %d", params[1]);
+		return 0;
+	}
+
+	IResultSet *rs = oldrs->info.rs;
+	IResultRow *rr = rs->GetRow();
+	unsigned int num = (unsigned int)params[2] - 1;
+	if (num >= rs->FieldCount())
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid column %d", params[2]);
+		return 0;
+	}
+
+	cell stype = params[0] / sizeof(cell);
+	const char *data = rr->GetString(num);
+	if (!data)
+		data = "";
+
+	switch (stype)
+	{
+	case 2:
+		{
+			return atoi(data);
+			break;
+		}
+	case 3:
+		{
+			cell *destaddr = MF_GetAmxAddr(amx, params[3]);
+			REAL fdata = atof(data);
+			*destaddr = amx_ftoc(fdata);
+			return 1;
+			break;
+		}
+	case 4:
+		{
+			return MF_SetAmxString(amx, params[3], data, params[4]);
+			break;
+		}
+	}
+
+	/** never reach here */
+	return 0;
+}
+
+//native dbi_result(Result:_result, _field[], {Float,_}:... );
+static cell AMX_NATIVE_CALL dbi_result(AMX *amx, cell *params)
+{
+	oldresult_s *oldrs = (oldresult_s *)GetHandle(params[1], Handle_OldResult);
+	if (!oldrs)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI result handle %d", params[1]);
+		return 0;
+	}
+
+	IResultSet *rs = oldrs->info.rs;
+	IResultRow *rr = rs->GetRow();
+	unsigned int num;
+	bool found = false;
+	unsigned int fields = rs->FieldCount();
+	int len;
+	char *field = MF_GetAmxString(amx, params[2], 0, &len);
+	for (unsigned int i=0; i<fields; i++)
+	{
+		if (strcmp(field, rs->FieldNumToName(i)) == 0)
+		{
+			num = i;
+			found = true;
+			break;
+		}
+	}
+
+	if (!found)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Unknown column \"%s\"", field);
+		return 0;
+	}
+
+	cell stype = params[0] / sizeof(cell);
+	const char *data = rr->GetString(num);
+	if (!data)
+		data = "";
+
+	switch (stype)
+	{
+	case 2:
+		{
+			return atoi(data);
+			break;
+		}
+	case 3:
+		{
+			cell *destaddr = MF_GetAmxAddr(amx, params[3]);
+			REAL fdata = atof(data);
+			*destaddr = amx_ftoc(fdata);
+			return 1;
+			break;
+		}
+	case 4:
+		{
+			return MF_SetAmxString(amx, params[3], data, params[4]);
+			break;
+		}
+	}
+
+	/** never reach here */
+	return 0;
+}
+
+//native dbi_num_rows(Result:_result);
+static cell AMX_NATIVE_CALL dbi_num_rows(AMX *amx, cell *params)
+{
+	oldresult_s *oldrs = (oldresult_s *)GetHandle(params[1], Handle_OldResult);
+	if (!oldrs)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI result handle %d", params[1]);
+		return 0;
+	}
+
+	return oldrs->info.rs->RowCount();
+}
+
+//native dbi_free_result(&Result:result);
+static cell AMX_NATIVE_CALL dbi_free_result(AMX *amx, cell *params)
+{
+	cell *_r = MF_GetAmxAddr(amx, params[1]);
+	cell num = *_r;
+
+	if (!num)
+	{
+		return 1;
+	}
+
+	oldresult_s *oldrs = (oldresult_s *)GetHandle(num, Handle_OldResult);
+	if (!oldrs)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI result handle %d", num);
+		return 0;
+	}
+
+	FreeHandle(num);
+
+	*_r = 0;
+
+	return 1;
+}
+
+//native dbi_close(&Sql:_sql);
+static cell AMX_NATIVE_CALL dbi_close(AMX *amx, cell *params)
+{
+	cell *_r = MF_GetAmxAddr(amx, params[1]);
+	cell num = *_r;
+	olddb_s *old = (olddb_s *)GetHandle(num, Handle_OldDb);
+	if (!old)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI handle %d", num);
+		return -1;
+	}
+
+	FreeHandle(num);
+
+	*_r = 0;
+
+	return 1;
+}
+
+//native dbi_error(Sql:_sql, _error[], _len);
+static cell AMX_NATIVE_CALL dbi_error(AMX *amx, cell *params)
+{
+	olddb_s *old = (olddb_s *)GetHandle(params[1], Handle_OldDb);
+	if (!old)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI handle %d", params[1]);
+		return -1;
+	}
+
+	MF_SetAmxString(amx, params[2], old->error, params[3]);
+	return old->errcode;
+}
+
+//native dbi_type(_type[], _len);
+static cell AMX_NATIVE_CALL dbi_type(AMX *amx, cell *params)
+{
+	return MF_SetAmxString(amx, params[1], "mysql", params[2]);
+}
+
+//native dbi_num_fields(Result:result);
+static cell AMX_NATIVE_CALL dbi_num_fields(AMX *amx, cell *params)
+{
+	oldresult_s *oldrs = (oldresult_s *)GetHandle(params[1], Handle_OldResult);
+	if (!oldrs)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI result handle %d", params[1]);
+		return 0;
+	}
+
+	return oldrs->info.rs->FieldCount();
+}
+
+//native dbi_field_name(Result:result, field, name[], maxLength);
+static cell AMX_NATIVE_CALL dbi_field_name(AMX *amx, cell *params)
+{
+	oldresult_s *oldrs = (oldresult_s *)GetHandle(params[1], Handle_OldResult);
+	if (!oldrs)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid DBI result handle %d", params[1]);
+		return 0;
+	}
+
+	const char *name = oldrs->info.rs->FieldNumToName(static_cast<unsigned int>(params[2]-1));
+	if (!name)
+		return 0;
+
+	MF_SetAmxString(amx, params[3], name, params[4]);
+
+	return 1;
+}
+
+AMX_NATIVE_INFO g_OldCompatNatives[] = 
+{
+	{ "dbi_connect",		dbi_connect },
+	{ "dbi_query",			dbi_query },
+	{ "dbi_query2",			dbi_query2 },
+	{ "dbi_field",			dbi_field },	
+	{ "dbi_nextrow",		dbi_nextrow },	
+	{ "dbi_close",			dbi_close },	
+	{ "dbi_error",			dbi_error },
+	{ "dbi_type",			dbi_type },
+	{ "dbi_free_result",	dbi_free_result },
+	{ "dbi_num_rows",		dbi_num_rows },
+	{ "dbi_result",			dbi_result },
+	{ "dbi_num_fields",		dbi_num_fields },
+	{ "dbi_field_name",		dbi_field_name },
+
+	{ NULL, NULL }
+};
diff --git a/dlls/sqlite/CVector.h b/dlls/sqlite/sdk/CVector.h
similarity index 83%
rename from dlls/sqlite/CVector.h
rename to dlls/sqlite/sdk/CVector.h
index d6b87eb5..45f0d548 100755
--- a/dlls/sqlite/CVector.h
+++ b/dlls/sqlite/sdk/CVector.h
@@ -70,32 +70,58 @@ template <class T> class CVector
 		// 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_Size < size) ? (m_Size) : size;
+			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;
 		}
-		if (m_Size < size)
-			m_CurrentSize = size;
 		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;
-	size_t m_CurrentSize;
 public:
 	class iterator
 	{
@@ -189,7 +215,7 @@ public:
 
 		iterator & operator-=(size_t offset)
 		{
-			m_Ptr += offset;
+			m_Ptr -= offset;
 			return (*this);
 		}
 
@@ -203,10 +229,10 @@ public:
 		iterator operator-(size_t offset) const
 		{
 			iterator tmp(*this);
-			tmp.m_Ptr += offset;
+			tmp.m_Ptr -= offset;
 			return tmp;
 		}
-		
+
 		T & operator[](size_t offset)
 		{
 			return (*(*this + offset));
@@ -277,12 +303,12 @@ public:
 		return m_Size;
 	}
 
-	iterator begin()
+	iterator begin() const
 	{
 		return iterator(m_Data);
 	}
 
-	iterator end()
+	iterator end() const
 	{
 		return iterator(m_Data + m_CurrentUsedSize);
 	}
@@ -296,7 +322,9 @@ public:
 
 	bool reserve(size_t newSize)
 	{
-		return ChangeSize(newSize);
+		if (newSize > m_Size)
+			return ChangeSize(newSize);
+		return true;
 	}
 
 	bool push_back(const T & elem)
@@ -317,14 +345,15 @@ public:
 		--m_CurrentUsedSize;
 		if (m_CurrentUsedSize < 0)
 			m_CurrentUsedSize = 0;
-		// :TODO: free memory sometimes
+
+		FreeMemIfPossible();
 	}
 
 	bool resize(size_t newSize)
 	{
 		if (!ChangeSize(newSize))
 			return false;
-		FreeMemIfPossible();
+		m_CurrentUsedSize = newSize;
 		return true;
 	}
 
@@ -397,15 +426,13 @@ public:
 		return m_Data[m_CurrentUsedSize - 1];
 	}
 
-	bool insert(iterator where, const T & value)
+	iterator insert(iterator where, const T & value)
 	{
-		// we have to insert before
-		// if it is begin, don't decrement
-		if (where != m_Data)
-			--where;
 		// validate iter
-		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
-			return false;
+		if (where < m_Data || where > (m_Data + m_CurrentUsedSize))
+			return iterator(0);
+
+		size_t ofs = where - begin();
 
 		++m_CurrentUsedSize;
 		if (!GrowIfNeeded())
@@ -414,33 +441,49 @@ public:
 			return false;
 		}
 
-		memmove(where.base() + 1, where.base(), m_CurrentUsedSize - (where - m_Data));
-		memcpy(where.base(), &value, sizeof(T));
-		return true;
+		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;
 	}
 
-	void erase(iterator where)
+	iterator erase(iterator where)
 	{
 		// validate iter
 		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
-			return false;
+			return iterator(0);
+
+		size_t ofs = where - begin();
 
 		if (m_CurrentUsedSize > 1)
 		{
 			// move
-			memmove(where.base(), where.base() + 1, m_CurrentUsedSize - 1);
+			T *theend = m_Data + m_CurrentUsedSize;
+			for (T *ptr = where.base() + 1; ptr < theend; ++ptr)
+				*(ptr - 1) = *ptr;
 		}
 
 		--m_CurrentUsedSize;
-		// :TODO: free memory sometimes
+
+		FreeMemIfPossible();
+
+		return begin() + ofs;
 	}
 
 	void clear()
 	{
 		m_Size = 0;
 		m_CurrentUsedSize = 0;
-		delete [] m_Data;
-		m_Data = NULL;
+		if (m_Data)
+		{
+			delete [] m_Data;
+			m_Data = NULL;
+		}
 	}
 };
 
diff --git a/dlls/sqlite/sdk/amxxmodule.cpp b/dlls/sqlite/sdk/amxxmodule.cpp
new file mode 100755
index 00000000..3492febb
--- /dev/null
+++ b/dlls/sqlite/sdk/amxxmodule.cpp
@@ -0,0 +1,3125 @@
+/* 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;
+PFN_AMX_REREGISTER			g_fn_AmxReRegister;
+PFN_REGISTERFUNCTIONEX		g_fn_RegisterFunctionEx;
+
+// *** 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);
+	REQFUNC("RegisterFunctionEx", g_fn_RegisterFunctionEx, PFN_REGISTERFUNCTIONEX);
+
+	// 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);
+
+	//Added in 1.75 
+	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);
+	REQFUNC("AmxReregister", g_fn_AmxReRegister, PFN_AMX_REREGISTER);
+
+#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_RegisterFunctionEx(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/sqlite/sdk/amxxmodule.h b/dlls/sqlite/sdk/amxxmodule.h
new file mode 100755
index 00000000..e74febf4
--- /dev/null
+++ b/dlls/sqlite/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
+#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*/);
+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 *	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/sqlite/sdk/moduleconfig.h b/dlls/sqlite/sdk/moduleconfig.h
new file mode 100755
index 00000000..5c0c14ed
--- /dev/null
+++ b/dlls/sqlite/sdk/moduleconfig.h
@@ -0,0 +1,491 @@
+// Configuration
+
+#ifndef __MODULECONFIG_H__
+#define __MODULECONFIG_H__
+
+// Module info
+#define MODULE_NAME "SQLiteX"
+#define MODULE_VERSION "1.75"
+#define MODULE_AUTHOR "AMX Mod X Dev Team"
+#define MODULE_URL "http://www.amxmodx.org/"
+#define MODULE_LOGTAG "SQLITEX"
+#define MODULE_LIBRARY "sqlitex"
+#define MODULE_LIBCLASS "sqlx"
+// 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				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/sqlite/sdk/sh_list.h b/dlls/sqlite/sdk/sh_list.h
new file mode 100644
index 00000000..be136c41
--- /dev/null
+++ b/dlls/sqlite/sdk/sh_list.h
@@ -0,0 +1,297 @@
+/* ======== SourceMM ========
+* Copyright (C) 2004-2005 Metamod:Source Development Team
+* No warranties of any kind
+*
+* License: zlib/libpng
+*
+* Author(s): David "BAILOPAN" Anderson
+* ============================
+*/
+
+#ifndef _INCLUDE_SMM_LIST_H
+#define _INCLUDE_SMM_LIST_H
+
+// MSVC8 fix for offsetof macro redefition warnings
+#ifdef _MSC_VER 
+	#if _MSC_VER >= 1400
+		#undef offsetof
+	#endif
+#endif
+
+#include <new>
+#include <malloc.h>
+
+namespace SourceHook
+{
+	//This class is from CSDM for AMX Mod X
+	/*
+		A circular, doubly-linked list with one sentinel node
+
+		Empty:
+			m_Head = sentinel
+			m_Head->next = m_Head;
+			m_Head->prev = m_Head;
+		One element:
+			m_Head = sentinel
+			m_Head->next = node1
+			m_Head->prev = node1
+			node1->next = m_Head
+			node1->prev = m_Head
+		Two elements:
+			m_Head = sentinel
+			m_Head->next = node1
+			m_Head->prev = node2
+			node1->next = node2
+			node1->prev = m_Head
+			node2->next = m_Head
+			node2->prev = node1
+	*/
+	template <class T>
+	class List
+	{
+	public:
+		class iterator;
+		friend class iterator;
+		class ListNode
+		{
+		public:
+			ListNode(const T & o) : obj(o) { };
+			ListNode() { };
+			T obj;
+			ListNode *next;
+			ListNode *prev;
+		};
+	private:
+		// Initializes the sentinel node.
+		// BAIL used malloc instead of new in order to bypass the need for a constructor.
+		ListNode *_Initialize()
+		{
+			ListNode *n = (ListNode *)malloc(sizeof(ListNode));
+			n->next = n;
+			n->prev = n;
+			return n;
+		}
+	public:
+		List() : m_Head(_Initialize()), m_Size(0)
+		{
+		}
+		List(const List &src) : m_Head(_Initialize()), m_Size(0)
+		{
+			iterator iter;
+			for (iter=src.begin(); iter!=src.end(); iter++)
+				push_back( (*iter) );
+		}
+		~List()
+		{
+			clear();
+
+			// Don't forget to free the sentinel
+			if (m_Head)
+			{
+				free(m_Head);
+				m_Head = NULL;
+			}
+		}
+		void push_back(const T &obj)
+		{
+			ListNode *node = new ListNode(obj);
+
+			node->prev = m_Head->prev;
+			node->next = m_Head;
+			m_Head->prev->next = node;
+			m_Head->prev = node;
+
+			m_Size++;
+		}
+		size_t size()
+		{
+			return m_Size;
+		}
+
+		void clear()
+		{
+			ListNode *node = m_Head->next;
+			ListNode *temp;
+			m_Head->next = m_Head;
+			m_Head->prev = m_Head;
+
+			// Iterate through the nodes until we find g_Head (the sentinel) again
+			while (node != m_Head)
+			{
+				temp = node->next;
+				delete node;
+				node = temp;
+			}
+			m_Size = 0;
+		}
+		bool empty()
+		{
+			return (m_Size == 0);
+		}
+		T & back()
+		{
+			return m_Head->prev->obj;
+		}
+	private:
+		ListNode *m_Head;
+		size_t m_Size;
+	public:
+		class iterator
+		{
+		friend class List;
+		public:
+			iterator()
+			{
+				m_This = NULL;
+			}
+			iterator(const List &src)
+			{
+				m_This = src.m_Head;
+			}
+			iterator(ListNode *n) : m_This(n)
+			{
+			}
+			iterator(const iterator &where)
+			{
+				m_This = where.m_This;
+			}
+			//pre decrement
+			iterator & operator--()
+			{
+				if (m_This)
+					m_This = m_This->prev;
+				return *this;
+			}
+			//post decrement
+			iterator operator--(int)
+			{
+				iterator old(*this);
+				if (m_This)
+					m_This = m_This->prev;
+				return old;
+			}	
+			
+			//pre increment
+			iterator & operator++()
+			{
+				if (m_This)
+					m_This = m_This->next;
+				return *this;
+			}
+			//post increment
+			iterator operator++(int)
+			{
+				iterator old(*this);
+				if (m_This)
+					m_This = m_This->next;
+				return old;
+			}
+			
+			const T & operator * () const
+			{
+				return m_This->obj;
+			}
+			T & operator * ()
+			{
+				return m_This->obj;
+			}
+			
+			T * operator -> ()
+			{
+				return &(m_This->obj);
+			}
+			const T * operator -> () const
+			{
+				return &(m_This->obj);
+			}
+			
+			bool operator != (const iterator &where) const
+			{
+				return (m_This != where.m_This);
+			}
+			bool operator ==(const iterator &where) const
+			{
+				return (m_This == where.m_This);
+			}
+		private:
+			ListNode *m_This;
+		};
+	public:
+		iterator begin() const
+		{
+			return iterator(m_Head->next);
+		}
+		iterator end() const
+		{
+			return iterator(m_Head);
+		}
+		iterator erase(iterator &where)
+		{
+			ListNode *pNode = where.m_This;
+			iterator iter(where);
+			iter++;
+
+
+			// Works for all cases: empty list, erasing first element, erasing tail, erasing in the middle...
+			pNode->prev->next = pNode->next;
+			pNode->next->prev = pNode->prev;
+
+			delete pNode;
+			m_Size--;
+
+			return iter;
+		}
+
+		iterator insert(iterator where, const T &obj)
+		{
+			// Insert obj right before where
+
+			ListNode *node = new ListNode(obj);
+			ListNode *pWhereNode = where.m_This;
+			
+			pWhereNode->prev->next = node;
+			node->prev = pWhereNode->prev;
+			pWhereNode->prev = node;
+			node->next = pWhereNode;
+
+			m_Size++;
+
+			return iterator(node);
+		}
+
+	public:
+		void remove(const T & obj)
+		{
+			iterator b;
+			for (b=begin(); b!=end(); b++)
+			{
+				if ( (*b) == obj )
+				{
+					erase( b );
+					break;
+				}
+			}
+		}
+		template <typename U>
+		iterator find(const U & equ)
+		{
+			iterator iter;
+			for (iter=begin(); iter!=end(); iter++)
+			{
+				if ( (*iter) == equ )
+					return iter;
+			}
+			return end();
+		}
+		List & operator =(const List &src)
+		{
+			clear();
+			iterator iter;
+			for (iter=src.begin(); iter!=src.end(); iter++)
+				push_back( (*iter) );
+			return *this;
+		}
+	};
+};	//NAMESPACE
+
+#endif //_INCLUDE_CSDM_LIST_H
diff --git a/dlls/sqlite/sdk/sh_stack.h b/dlls/sqlite/sdk/sh_stack.h
new file mode 100755
index 00000000..04158ca1
--- /dev/null
+++ b/dlls/sqlite/sdk/sh_stack.h
@@ -0,0 +1,219 @@
+/* ======== SourceMM ========
+* Copyright (C) 2004-2005 Metamod:Source Development Team
+* No warranties of any kind
+*
+* License: zlib/libpng
+*
+* Author(s): Pavol "PM OnoTo" Marko
+* ============================
+*/
+
+#ifndef __SH_STACK_H__
+#define __SH_STACK_H__
+
+#define SH_STACK_DEFAULT_SIZE 4
+
+//namespace SourceHook
+//{/
+	// Vector
+	template <class T> class CStack
+	{
+		T *m_Elements;
+		size_t m_AllocatedSize;
+		size_t m_UsedSize;
+	public:
+		friend class iterator;
+		class iterator
+		{
+			CStack<T> *m_pParent;
+			size_t m_Index;
+		public:
+			iterator(CStack<T> *pParent, size_t id) : m_pParent(pParent), m_Index(id)
+			{
+			}
+
+			iterator(CStack<T> *pParent) : m_pParent(pParent), m_Index(0)
+			{
+			}
+			
+			iterator() : m_pParent(NULL), m_Index(0)
+			{
+			}
+
+			T &operator *()
+			{
+				return m_pParent->m_Elements[m_Index];
+			}
+			const T &operator *() const
+			{
+				return m_pParent->m_Elements[m_Index];
+			}
+			
+			T * operator->()
+			{
+				return m_pParent->m_Elements + m_Index;
+			}
+
+			const T * operator->() const
+			{
+				return m_pParent->m_Elements + m_Index;
+			}
+
+			iterator & operator++()		// preincrement
+			{
+				++m_Index;
+				return (*this);
+			}
+
+			iterator operator++(int)	// postincrement
+			{
+				iterator tmp = *this;
+				++m_Index;
+				return tmp;
+			}
+
+			iterator & operator--()		// predecrement
+			{
+				--m_Index;
+				return (*this);
+			}
+
+			iterator operator--(int)	// postdecrememnt
+			{
+				iterator tmp = *this;
+				--m_Index;
+				return tmp;
+			}
+
+			bool operator==(const iterator & right) const
+			{
+				return (m_pParent == right.m_pParent && m_Index == right.m_Index);
+			}
+
+			bool operator!=(const iterator & right) const
+			{
+				return !(*this == right);
+			}
+		};
+		CStack() : m_Elements(new T[SH_STACK_DEFAULT_SIZE]),
+			m_AllocatedSize(SH_STACK_DEFAULT_SIZE),
+			m_UsedSize(0)
+		{
+		}
+		CStack(size_t size) : m_Elements(new T[size]),
+			m_AllocatedSize(size),
+			m_UsedSize(0)
+		{
+		}
+
+		CStack(const CStack &other) : m_Elements(NULL),
+			m_AllocatedSize(0),
+			m_UsedSize(0)
+		{
+			reserve(other.m_AllocatedSize);
+			m_UsedSize = other.m_UsedSize;
+			for (size_t i = 0; i < m_UsedSize; ++i)
+				m_Elements[i] = other.m_Elements[i];
+		}
+
+		~CStack()
+		{
+			if (m_Elements)
+				delete [] m_Elements;
+		}
+		
+		void operator=(const CStack &other)
+		{
+			if (m_AllocatedSize < other.m_AllocatedSize)
+			{
+				if (m_Elements)
+					delete [] m_Elements;
+				m_Elements = new T[other.m_AllocatedSize];
+				m_AllocatedSize = other.m_AllocatedSize;
+			}
+			m_UsedSize = other.m_UsedSize;
+			for (size_t i = 0; i < m_UsedSize; ++i)
+				m_Elements[i] = other.m_Elements[i];
+		}
+
+		bool push(const T &val)
+		{
+			if (m_UsedSize + 1 == m_AllocatedSize)
+			{
+				// zOHNOES! REALLOCATE!
+				m_AllocatedSize *= 2;
+				T *newElements = new T[m_AllocatedSize];
+				if (!newElements)
+				{
+					m_AllocatedSize /= 2;
+					return false;
+				}
+				if (m_Elements)
+				{
+					for (size_t i = 0; i < m_UsedSize; ++i)
+						newElements[i] = m_Elements[i];
+					delete [] m_Elements;
+				}
+				m_Elements = newElements;
+			}
+			m_Elements[m_UsedSize++] = val;
+			return true;
+		}
+		void pop()
+		{
+			--m_UsedSize;
+		}
+
+		T &front()
+		{
+			return m_Elements[m_UsedSize - 1];
+		}
+
+		const T &front() const
+		{
+			return m_Elements[m_UsedSize - 1];
+		}
+
+		iterator begin()
+		{
+			return iterator(this, 0);
+		}
+		iterator end()
+		{
+			return iterator(this, m_UsedSize);
+		}
+
+		size_t size()
+		{
+			return m_UsedSize;
+		}
+		size_t capacity()
+		{
+			return m_AllocatedSize;
+		}
+		bool empty()
+		{
+			return m_UsedSize == 0 ? true : false;
+		}
+		bool reserve(size_t size)
+		{
+			if (size > m_AllocatedSize)
+			{
+				T *newElements = new T[size];
+				if (!newElements)
+					return false;
+				if (m_Elements)
+				{
+					for (size_t i = 0; i < m_UsedSize; ++i)
+						newElements[i] = m_Elements[i];
+					delete [] m_Elements;
+				}
+				m_Elements = newElements;
+				m_AllocatedSize = size;
+			}
+			return true;
+		}
+	};
+//};	//namespace SourceHook
+
+#endif
diff --git a/dlls/sqlite/CString.h b/dlls/sqlite/sdk/sh_string.h
similarity index 72%
rename from dlls/sqlite/CString.h
rename to dlls/sqlite/sdk/sh_string.h
index 14b86509..08bc6ebb 100755
--- a/dlls/sqlite/CString.h
+++ b/dlls/sqlite/sdk/sh_string.h
@@ -1,41 +1,26 @@
-/* AMX Mod X
+/* ======== SourceMM ========
+* Copyright (C) 2004-2005 Metamod:Source Development Team
+* No warranties of any kind
 *
-* by the AMX Mod X Development Team
-*  originally developed by OLO
+* License: zlib/libpng
 *
-*
-*  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.
+* Author(s): David "BAILOPAN" Anderson
+* ============================
 */
 
+/* AMX Mod X
+ *
+ * by the AMX Mod X Development Team
+ */
+
 #ifndef _INCLUDE_CSTRING_H
 #define _INCLUDE_CSTRING_H
 
 #include <string.h>
 #include <stdio.h>
 
-//by David "BAILOPAN" Anderson
+namespace SourceHook
+{
 class String
 {
 public:
@@ -59,13 +44,6 @@ public:
 		assign(src); 
 	}
 
-	const char * _fread(FILE *fp) 	 
-	{ 	 
-		Grow(512, false); 	 
-		char *ret = fgets(v, 511, fp); 	 
-		return ret; 	 
-	}
-
 	String(const String &src) 
 	{
 		v = NULL;
@@ -107,10 +85,8 @@ public:
 		{
 			clear();
 		} else {
-			size_t len = strlen(d);
-			Grow(len + 1, false);
-			memcpy(v, d, len);
-			v[len] = '\0';
+			Grow(strlen(d) + 1, false);
+			strcpy(v, d);
 		}
 	}
 
@@ -120,7 +96,7 @@ public:
 			v[0] = '\0';
 	}
 
-	int compare (const char *d) const
+	int compare (const char *d)
 	{
 		if (!v)
 			return strcmp("", d);
@@ -386,4 +362,6 @@ public:
 	static const int npos = -1;
 };
 
+};	//NAMESPACE
+
 #endif //_INCLUDE_CSTRING_H
diff --git a/dlls/sqlite/sqlheaders.h b/dlls/sqlite/sqlheaders.h
new file mode 100644
index 00000000..e756f703
--- /dev/null
+++ b/dlls/sqlite/sqlheaders.h
@@ -0,0 +1,17 @@
+#ifndef _INCLUDE_SQLHEADERS_H
+#define _INCLUDE_SQLHEADERS_H
+
+#include "ISQLDriver.h"
+
+#define SQL_DRIVER_FUNC	"GetSqlFuncs"
+
+typedef int (*SQLAFFINITY)(AMX *amx);
+
+struct SqlFunctions
+{
+	SourceMod::ISQLDriver *driver;
+	SQLAFFINITY set_affinity;
+	SqlFunctions *prev;
+};
+
+#endif //_INCLUDE_SQLHEADERS_H
diff --git a/dlls/sqlite/sqlite.cpp b/dlls/sqlite/sqlite.cpp
deleted file mode 100755
index 8cade29a..00000000
--- a/dlls/sqlite/sqlite.cpp
+++ /dev/null
@@ -1,458 +0,0 @@
-/* AMX Mod X
-*	 MySQL Module
-*
-* by the AMX Mod X Development Team
-*
-* This file is part of AMX Mod X.
-*
-*
-*	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.
-*/
-
-#include <stdarg.h>
-#include "sqlite_amx.h"
-
-unsigned int lastDb;
-
-CVector<SQLResult*> Results;
-CVector<SQL*> DBList;
-
-// ///////////////////////////////
-// Sqlite natives for AMX scripting
-// ///////////////////////////////
-
-// Sql:dbi_connect(host[],user[],pass[],dbname[],error[],maxlength) :
-// - open connection
-// not used: host, user, pass
-static cell AMX_NATIVE_CALL sql_connect(AMX *amx, cell *params) //	6 param
-{
-	int i = 0;
-	int id = -1;
-	//char *host = MF_GetAmxString(amx,params[1], 0, &i);
-	//char *user = MF_GetAmxString(amx,params[2], 1, &i);
-	//char *pass = MF_GetAmxString(amx,params[3], 2, &i);
-	char *dbname = MF_GetAmxString(amx,params[4], 3, &i);
-	i = 0;
-
-	if (!strlen(dbname)) {
-		MF_LogError(amx, AMX_ERR_NATIVE, "Received invalid parameter.");
-		return -1;
-	}
-	
-	SQL *c=NULL;
-	
-	for (i=0; (unsigned int)i<DBList.size(); i++) {
-		if (DBList[i]->isFree) {
-			id = i;
-			break;
-		}
-	}
-
-	if (id>=0) {
-		c = DBList[id];
-	} else {
-		c = new SQL;
-		DBList.push_back(c);
-		id = (unsigned int)(DBList.size() - 1);
-	}
-
-	char pathbuffer[1024];
-	MF_BuildPathnameR(pathbuffer, 1023, "%s", dbname);
-#if defined _DEBUG
-	MF_PrintSrvConsole("Sqlite connect uses path: \"%s\"\n", pathbuffer);
-#endif
-	
-	if (!c->Connect(pathbuffer))
-	{
-		if (c->ErrorStr.size() < 1)
-		{
-			c->Error();
-		}
-		MF_SetAmxString(amx, params[5], c->ErrorStr.c_str(), params[6]);
-		return CONNECT_FAILED;
-	}
-
-    MF_SetAmxString(amx,params[5],"",params[6]);
-
-	lastDb = id;
-	
-	return id+1;
-}
-
-// dbi_error(Sql:sql,dest[],maxlength)
-// - store maxlength characters from mysql error in current row to dest
-static cell AMX_NATIVE_CALL sql_error(AMX *amx, cell *params) // 3 params
-{
-	unsigned int id = params[1]-1;
-	if (id >= DBList.size() || DBList[id]->isFree)
-		id = lastDb;
-
-	SQL *sql = DBList[id];
-	
-	if (sql->ErrorStr.size() > 1)
-	{
-		MF_SetAmxString(amx, params[2], sql->ErrorStr.c_str(), params[3]);
-		sql->ErrorStr.assign("");
-		return 1;
-	} else {
-		sql->Error();
-		if (sql->ErrorStr.size() > 1)
-		{
-			MF_SetAmxString(amx, params[2], sql->ErrorStr.c_str(), params[3]);
-			sql->ErrorStr.assign("");
-			return 1;
-		}
-	}
-	MF_SetAmxString(amx, params[2], "", params[3]);
-
-	return 0;
-}
-
-// Result:dbi_query(Sql:sql,query[]) - returns 0 on success, <0 on failure, >0 on result set
-static cell AMX_NATIVE_CALL sql_query(AMX *amx, cell *params) //	2 params
-{
-	unsigned int id = params[1] - 1;
-
-	if (id >= DBList.size() || DBList[id]->isFree) {
-		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid database handle %d", id);
-		return QUERY_FAILED;
-	}
-
-	lastDb = id;
-
-	int len = 0;
-	const char *query = MF_FormatAmxString(amx, params, 2, &len);
-
-	SQL *sql = DBList[id];
-
-	return sql->Query(query);	//Return the result set handle, if any
-}
-
-// dbi_nextrow(Sql:sql) :
-// - read next row
-// - return :
-//	 . number of line
-//	 . 0 at end
-static cell AMX_NATIVE_CALL sql_nextrow(AMX *amx, cell *params) //	1 param
-{
-	unsigned int id = params[1]-1;
-
-	if (id == -1)
-	{
-		//the user should have checked, but we'll return 0 anyway
-		return 0;
-	}
-
-	if (id >= Results.size() || Results[id]->isFree)
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid result handle %d", id);
-		return 0;
-	}
-
-	SQLResult *Result = Results[id];
-
-	return Result->Nextrow();
-}
-
-// dbi_close(Sql:sql) :
-// - free result
-// - close connection
-static cell AMX_NATIVE_CALL sql_close(AMX *amx, cell *params) // 1 param
-{
-	cell *addr = MF_GetAmxAddr(amx, params[1]);
-	unsigned int id = (*addr) - 1;
-	if (id >= DBList.size() || DBList[id]->isFree) {
-		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid database handle %d", id);
-		return 0;
-	}
-
-	lastDb = id;
-
-	SQL *sql = DBList[id];
-	
-	sql->Disconnect();
-
-	*addr = 0;
-
-	return 1;
-}
-
-//Returns a field from a query result handle.
-// 2 param - returns integer
-// 3 param - stores float in cell byref
-// 4 param - stores string
-static cell AMX_NATIVE_CALL sql_getfield(AMX *amx, cell *params) // 2-4 params
-{
-	unsigned int id = params[1]-1;
-
-	if (id >= Results.size() || Results[id]->isFree)
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid result handle %d.", id);
-		return 0;
-	}
-
-	SQLResult *Result = Results[id];
-	if (Result->m_rowCount == 0)
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Record set is empty.");
-		return 0;
-	}
-
-	int numParams = (*params)/sizeof(cell);
-	cell *fAddr = NULL;
-	const char *field = Result->GetField(params[2]-1);
-	if (field == NULL)
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Field error.");
-		return 0;
-	}
-
-	switch (numParams)
-	{
-	case 2:
-		return atoi(field);
-		break;
-	case 3:
-		fAddr = MF_GetAmxAddr(amx, params[3]);
-		*fAddr = amx_ftoc((REAL)atof(field));
-		return 1;
-		break;
-	case 4:
-		return MF_SetAmxString(amx, params[3], field?field:"", *(MF_GetAmxAddr(amx, params[4])));
-		break;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-//Returns a field from a query result handle.
-// 2 param - returns integer
-// 3 param - stores float in cell byref
-// 4 param - stores string
-static cell AMX_NATIVE_CALL sql_getresult(AMX *amx, cell *params) // 4 params
-{
-	unsigned int id = params[1]-1;
-
-	if (id >= Results.size())
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid result handle %d", id);
-		return 0;
-	}
-
-	SQLResult *Result = Results[id];
-	int numParams = (*params)/sizeof(cell);
-	cell *fAddr = NULL;
-	int len = 0;
-	const char *column = MF_GetAmxString(amx, params[2], 0, &len);
-	const char *field = Result->GetField(column);
-	if (field == NULL)
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Unknown error");
-		return 0;
-	}
-
-	switch (numParams)
-	{
-	case 2:
-		return atoi(field);
-		break;
-	case 3:
-		fAddr = MF_GetAmxAddr(amx, params[3]);
-		*fAddr = amx_ftoc((REAL)atof(field));
-		return 1;
-		break;
-	case 4:
-		len = *(MF_GetAmxAddr(amx, params[4]));
-		return MF_SetAmxString(amx, params[3], field?field:"", params[4]);
-		break;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-static cell AMX_NATIVE_CALL sql_free_result(AMX *amx, cell *params)
-{
-	cell *addr = (MF_GetAmxAddr(amx, params[1]));
-	unsigned int id = (*addr) - 1;
-
-	if (id == -1)
-	{
-		//the user should have checked, but we'll return 0 anyway
-		return 0;
-	}
-
-	if (id >= Results.size())
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid result handle %d", id);
-		return 0;
-	}
-
-	SQLResult *Result = Results[id];
-
-	*addr = 0;
-
-	if (Result->isFree) {
-		MF_LogError(amx, AMX_ERR_NATIVE, "Tried to free result %d, but the result was already free!", id + 1);
-		return 0;
-	}
-
-	Result->FreeResult();
-
-#if defined _DEBUG
-	if (id + 1 == SQLResult::latestStoredResultId)
-		MF_PrintSrvConsole("***FREED: %d\n", id + 1);
-	else
-		MF_PrintSrvConsole("***FREED: %d WARNING LAST STORED: %d!\n", id + 1, SQLResult::latestStoredResultId);
-#endif
-
-	return 1;
-}
-
-static cell AMX_NATIVE_CALL sql_num_rows(AMX *amx, cell *params)
-{
-	unsigned int id = params[1]-1;
-
-	if (id == -1)
-	{
-		//the user should have checked, but we'll return 0 anyway
-		return 0;
-	}
-
-	if (id >= Results.size() || Results[id]->isFree)
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid result handle %d", id);
-		return 0;
-	}
-
-	SQLResult *Result = Results[id];
-
-	return (cell)Result->NumRows();
-}
-
-static cell AMX_NATIVE_CALL sql_type(AMX *amx, cell *params)
-{
-	return MF_SetAmxString(amx, params[1], "sqlite", params[2]);
-}
-
-static cell AMX_NATIVE_CALL sql_num_fields(AMX *amx, cell *params)
-{
-	unsigned int id = params[1]-1;
-
-	if (id == -1)
-	{
-		//the user should have checked, but we'll return 0 anyway
-		return 0;
-	}
-
-	if (id >= Results.size() || Results[id]->isFree)
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid result handle %d", id);
-		return 0;
-	}
-
-	SQLResult *Result = Results[id];
-
-	return Result->m_columnCount;
-}
-
-static cell AMX_NATIVE_CALL sql_field_name(AMX *amx, cell *params)
-{
-	unsigned int id = params[1]-1;
-
-	if (id == -1)
-	{
-		//the user should have checked, but we'll return 0 anyway
-		return 0;
-	}
-
-	if (id >= Results.size() || Results[id]->isFree)
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid result handle %d", id);
-		return 0;
-	}
-
-	SQLResult *Result = Results[id];
-
-	int field = params[2];
-
-	if (field < 1 || field > (int)Result->m_columnCount)
-	{
-		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid field number %d", field);
-		return 0;
-	}
-
-	MF_SetAmxString(amx, params[3], Result->m_fieldNames[field-1].c_str(), params[4]);
-
-	return 1;
-}
-
-AMX_NATIVE_INFO mysql_Natives[] = {
-	{ "dbi_connect",		sql_connect },
-	{ "dbi_query",			sql_query },	
-	{ "dbi_field",			sql_getfield },	
-	{ "dbi_nextrow",		sql_nextrow },	
-	{ "dbi_close",			sql_close },	
-	{ "dbi_error",			sql_error },
-	{ "dbi_type",			sql_type },
-	{ "dbi_free_result",	sql_free_result },
-	{ "dbi_num_rows",		sql_num_rows },
-	{ "dbi_result",			sql_getresult },
-	{ "dbi_num_fields",		sql_num_fields },
-	{ "dbi_field_name",		sql_field_name },
-	{ NULL, NULL }
-};
-
-void OnAmxxAttach()
-{
-	SQLResult *Dump = new SQLResult;
-	Dump->isFree = false;
-	Results.push_back(Dump);
-	MF_OverrideNatives(mysql_Natives);
-	MF_AddNatives(mysql_Natives);
-}
-
-void OnAmxxDetach()
-{
-	unsigned int i = 0;
-	for (i=0; i<Results.size(); i++)
-	{
-		if (!Results[i]->isFree)
-			Results[i]->FreeResult();
-		delete Results[i];
-	}
-	for (i=0; i<DBList.size(); i++)
-	{
-		DBList[i]->Disconnect();
-		delete DBList[i];
-	}
-	Results.clear();
-	DBList.clear();
-
-	//RETURN_META(MRES_IGNORED);
-}
diff --git a/dlls/sqlite/sqlite_amx.cpp b/dlls/sqlite/sqlite_amx.cpp
deleted file mode 100755
index b024660e..00000000
--- a/dlls/sqlite/sqlite_amx.cpp
+++ /dev/null
@@ -1,270 +0,0 @@
-#include "sqlite_amx.h"
-
-SQL::SQL()
-{
-	isFree = true;
-	sqlite = NULL;
-}
-
-SQL::~SQL()
-{
-	if (!isFree)
-		Disconnect();
-}
-int SQL::Error()
-{
-	if (sqlite == NULL)
-		return 0;
-
-	ErrorCode = sqlite3_errcode(sqlite);
-	ErrorStr.assign(sqlite3_errmsg(sqlite));
-
-	return ErrorCode;
-}
-
-int SQL::Connect(const char *base)
-{
-	Database.assign(base);
-
-	isFree = false;
-	int err = 0;
-	
-	this->ErrorCode = sqlite3_open(Database.c_str(), &sqlite);
-	if (ErrorCode != SQLITE_OK) {
-		err = Error();
-		if (err)
-		{
-			MF_Log("DB Connection failed(%d): %s", err, sqlite3_errmsg(sqlite));
-			sqlite3_close(sqlite);
-			isFree = true;
-			return 0;
-		}
-	}
-
-	isFree = false;
-
-	return 1;
-}
-
-void SQL::Disconnect()
-{
-	Database.clear();
-
-	if (sqlite != NULL)
-		sqlite3_close(sqlite);
-
-	sqlite = NULL;
-
-	isFree = true;
-}
-
-int SQL::Query(const char *query)
-{
-	if (sqlite == NULL || isFree)
-	{
-		ErrorCode = -1;
-		return -1;
-	}
-
-	unsigned int i = 0;
-	int id = -1;
-	for (i=0; i < Results.size(); i++)
-	{
-		if (Results[i]->isFree) {
-			id = i;
-			break;
-		}
-	}
-
-	if (id < 0) {
-
-		SQLResult *p = new SQLResult;
-
-		int ret = p->Query(this, query);
-
-		if (ret != 0)
-		{
-			delete p;
-
-			if (ret == -1)
-				return 0;
-			else
-				return -1;
-		} else {
-			Results.push_back(p);
-#if defined _DEBUG
-			MF_PrintSrvConsole("***STORE: %d (push_back)\n", Results.size());
-			SQLResult::latestStoredResultId = Results.size();
-#endif
-
-			return Results.size();
-		}
-	} else {
-		SQLResult *r = Results[id];
-		int ret = Results[id]->Query(this, query);
-		if (ret != 0)
-		{
-			if (ret == -1)
-				return 0;
-			else
-				return -1;
-		} else {
-#if defined _DEBUG
-			MF_PrintSrvConsole("***STORE: %d\n", id + 1);
-			SQLResult::latestStoredResultId = id + 1;
-#endif
-			return (id + 1);
-		}
-	}
-}
-
-SQLResult::SQLResult()
-{
-	isFree = true;
-	m_fieldNames = 0;
-	m_hasData = false;
-	m_currentRow = -1;
-	m_data = NULL;
-	m_errorMsg = NULL;
-	m_rowCount = 0;
-	m_columnCount = 0;
-}
-
-SQLResult::~SQLResult()
-{
-	if (!isFree)
-		FreeResult();
-}
-
-int SQLResult::Query(SQL *cn, const char *query)
-{
-	/*
-	int sqlite3_get_table(
-	sqlite3*,               // An open database 
-	const char *sql,       // SQL to be executed 
-	char ***resultp,       // Result written to a char *[]  that this points to 
-	int *nrow,             // Number of result rows written here 
-	int *ncolumn,          // Number of result columns written here 
-	char **errmsg          // Error msg written here 
-	);
-	*/
-	int rowCount, columnCount;
-	int result = sqlite3_get_table(cn->sqlite, query, &m_data, &rowCount, &columnCount, &m_errorMsg);
-	m_rowCount = rowCount;
-	m_columnCount = columnCount;
-	if (result != SQLITE_OK)
-	{
-		MF_Log("Query error: %s", m_errorMsg);
-		return 1;
-	}
-	else {
-		if (!m_rowCount)
-			return -1;
-		m_hasData = true;
-		this->m_fieldNames = new String[m_columnCount];
-		for (unsigned int i = 0; i < m_columnCount; i++)
-			m_fieldNames[i].assign(m_data[i]);
-
-#if defined _DEBUG
-		MF_PrintSrvConsole("SQLite: Select query returned %d rows in %d columns.\n", m_rowCount, m_columnCount);
-		for (unsigned int i = 0; i < m_columnCount; i++) {
-			MF_PrintSrvConsole("%15s", m_fieldNames[i].c_str());
-		}
-		MF_PrintSrvConsole("\n");
-		for (unsigned int i = 0; i < m_rowCount; i++) {
-			for (unsigned int j = 0; j < m_columnCount; j++) {
-				MF_PrintSrvConsole("%15s", m_data[(1 + i) * m_columnCount + j]);
-			}
-			MF_PrintSrvConsole("\n");
-		}
-#endif
-	}
-
-	isFree = false;
-	return 0; // Return 0 here? and 1 on error... 0's get stored and 1's get deleted
-}
-
-bool SQLResult::Nextrow()
-{
-	if (isFree)
-		return false;
-
-	if (++m_currentRow >= (int)this->m_rowCount) {
-		//m_currentRow = -1; <-- this is probably bad and inconsistent...
-		//FreeResult(); <-- this is probably bad and inconsistent... freeing should be the responsibility of the scripter
-		return false;
-	}
-
-	return true;
-}
-
-void SQLResult::FreeResult()
-{
-	if (isFree)
-		return;
-	/*
-#if defined _DEBUG
-	MF_PrintSrvConsole("FREEING a result!\n");
-#endif
-	*/
-	isFree = true;
-
-	if (m_hasData) {
-		sqlite3_free_table(m_data);
-
-		delete [] this->m_fieldNames;
-
-		m_hasData = false;
-	}
-
-	m_currentRow = -1;
-	m_columnCount = 0;
-	m_rowCount = 0;
-}
-
-const char *SQLResult::GetField(unsigned int field)
-{
-	if (isFree || field >= m_columnCount || m_currentRow < 0 || m_currentRow >= (int)m_rowCount)
-	{
-		return NULL;
-	}
-
-	char *data = m_data[(m_currentRow + 1) * m_columnCount + field];
-
-	return (data ? data : "");
-}
-
-const char *SQLResult::GetField(const char *field)
-{
-	unsigned int i = 0;
-	int id = -1;
-	if (field == NULL)
-		return NULL;
-	for (i=0; i < m_columnCount; i++)
-	{
-		if (strcmp(m_fieldNames[i].c_str(), field) == 0)
-		{
-			id = i;
-			break;
-		}
-	}
-
-	if (id<0 || id>=(int)m_columnCount)
-	{
-		return NULL;
-	}
-
-	return GetField(id);
-}
-
-unsigned int SQLResult::NumRows()
-{
-	if (isFree)
-		return 0;
-
-	return m_rowCount;
-}
-#if defined _DEBUG
-unsigned int SQLResult::latestStoredResultId = 0;
-#endif
-
diff --git a/dlls/sqlite/sqlite_amx.h b/dlls/sqlite/sqlite_amx.h
deleted file mode 100755
index 801f5eed..00000000
--- a/dlls/sqlite/sqlite_amx.h
+++ /dev/null
@@ -1,69 +0,0 @@
-
-
-#include <string.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <stdio.h>
-#ifndef __linux__
-#define WINDOWS_LEAN_AND_MEAN
-#include <winsock.h>
-#endif
-#include "amxxmodule.h"
-#include "CVector.h"
-#include "CString.h"
-#include "sqlite3.h"
-
-#define MEM_ALLOC_FAILED -20
-#define CONNECT_FAILED   -10
-#define QUERY_FAILED     -5
-
-class SQL
-{
-public:
-	SQL();
-	~SQL();
-	int Connect(/*const char *host, const char *user, const char *pass,*/ const char *base);
-	int Query(const char *query);
-	void Disconnect();
-	int Error();
-
-	sqlite3 *sqlite;
-
-	String ErrorStr;
-	int ErrorCode;
-
-	String Database;
-
-	bool isFree;
-};
-
-class SQLResult
-{
-public:
-	SQLResult();
-	~SQLResult();
-	int Query(SQL *cn, const char *query);
-	bool Nextrow();
-	void FreeResult();
-	const char *GetField(unsigned int field);
-	const char *GetField(const char *field);
-	unsigned int NumRows();
-	
-	String *m_fieldNames;
-	bool isFree;
-	int m_currentRow;
-	bool m_hasData;
-
-	char **m_data;
-	char *m_errorMsg;
-	unsigned int m_rowCount, m_columnCount;
-#if defined _DEBUG
-	static unsigned int latestStoredResultId;
-#endif
-};
-
-char *amx_string(AMX *amx, cell &param, int &len);
-
-extern CVector<SQLResult*> Results;
-extern CVector<SQL*> DBList;
-
diff --git a/dlls/sqlite/sqlite_header.h b/dlls/sqlite/sqlite_header.h
new file mode 100644
index 00000000..cc84b75a
--- /dev/null
+++ b/dlls/sqlite/sqlite_header.h
@@ -0,0 +1,54 @@
+#ifndef _INCLUDE_AMXMODX_MYSQL2_HEADER_H
+#define _INCLUDE_AMXMODX_MYSQL2_HEADER_H
+
+#include "SqliteDriver.h"
+#include "amxxmodule.h"
+#include "ThreadSupport.h"
+#include "ThreadWorker.h"
+
+#define SQLITE_THREADED
+
+struct AmxQueryInfo
+{
+	IQuery *pQuery;
+	QueryInfo info;
+	char error[255];
+};
+
+enum HandleType
+{
+	Handle_Invalid = -1,
+	Handle_Connection = 0,
+	Handle_Database,
+	Handle_Query,
+	Handle_OldDb,
+	Handle_OldResult,
+};
+
+struct SQL_Connection
+{
+	char *host;
+	char *user;
+	char *pass;
+	char *db;
+	int port;
+};
+
+typedef void (*FREEHANDLE)(void *, unsigned int);
+
+unsigned int MakeHandle(void *ptr, HandleType type, FREEHANDLE f);
+void *GetHandle(unsigned int num, HandleType type);
+bool FreeHandle(unsigned int num);
+void FreeAllHandles(HandleType type);
+void FreeHandleTable();
+void ShutdownThreading();
+int SetMysqlAffinity(AMX *amx);
+
+extern AMX_NATIVE_INFO g_BaseSqlNatives[];
+extern AMX_NATIVE_INFO g_ThreadSqlNatives[];
+extern AMX_NATIVE_INFO g_OldCompatNatives[];
+extern MainThreader g_Threader;
+extern ThreadWorker *g_pWorker;
+extern SourceMod::SqliteDriver g_Sqlite;
+
+#endif //_INCLUDE_AMXMODX_MYSQL2_HEADER_H
diff --git a/dlls/sqlite/sqlitepp/ISQLDriver.h b/dlls/sqlite/sqlitepp/ISQLDriver.h
new file mode 100644
index 00000000..7ae106cd
--- /dev/null
+++ b/dlls/sqlite/sqlitepp/ISQLDriver.h
@@ -0,0 +1,136 @@
+#ifndef _INCLUDE_SOURCEMOD_DATABASE2_H
+#define _INCLUDE_SOURCEMOD_DATABASE2_H
+
+#include <stdarg.h>
+
+namespace SourceMod
+{
+	class IResultRow
+	{
+	public:
+		/**
+		 * This will return NULL if the entry is NULL.
+		 * Remember that in SQL, a field can have NULL 
+		 *  entries, which are not the same as 0 or "".
+		 */
+		virtual const char *GetString(unsigned int columnId) =0;
+		virtual double GetDouble(unsigned int columnId) =0;
+		virtual float GetFloat(unsigned int columnId) =0;
+		virtual int GetInt(unsigned int columnId) =0;
+		virtual bool IsNull(unsigned int columnId) =0;
+		/**
+		 * NULL can be returned.  The length will be zero if so.
+		 */
+		virtual const char *GetRaw(unsigned int columnId, size_t *length) =0;
+	};
+
+	class IResultSet
+	{
+	public:
+		//free the handle if necessary (see IQuery).
+		virtual void FreeHandle() =0;
+	public: //Basic stuff
+		virtual unsigned int RowCount() =0;
+		virtual unsigned int FieldCount() =0;
+		virtual const char *FieldNumToName(unsigned int num) =0;
+		virtual bool FieldNameToNum(const char *name, unsigned int *columnId) =0;
+	public: //iteration
+		/**
+		 * Returns true if there are no more handles left.
+		 */
+		virtual bool IsDone() =0;
+		/**
+		 * Returns the current row.  If "IsDone()" is false
+		 *  this is guaranteed to return non-NULL.
+		 * Handles to IResultRow are guaranteed to not leak
+		 *  (you don't need to free them), however,
+		 *  they should be considered volatile - don't cache
+		 *  them.
+		 */
+		virtual IResultRow *GetRow() =0;
+		/**
+		 * Advances to the next row.  Note that you need to
+		 *  call IsDone() after each call to NextRow().
+		 */
+		virtual void NextRow() =0;
+	};
+
+	struct QueryInfo
+	{
+		IResultSet *rs;
+		unsigned long long affected_rows;
+		int errorcode;
+		bool success;
+	};
+
+	class IQuery
+	{
+	public:
+		//you must free the handle when done
+		virtual void FreeHandle() =0;
+	public:
+		/**
+		 * Executes the query.  Specify optional error string buffer.
+		 * If "info" is NULL, no results will be stored.
+		 * Returns false on failure.
+		 * Calling Execute() multiple times will cause each result handle
+		 *  to be freed in succession.  That means that you do not need to 
+		 *  explicitly free IResultSets when using Execute(), but their
+		 *  handles are deep-invalidated on succesive calls, and
+		 *  thus Execute() is also not thread safe.
+		 */
+		virtual bool Execute(QueryInfo *info, char *error, size_t maxlength) =0;
+		/**
+		 * Same as above, except result handles are not freed for you.
+		 */
+		virtual bool ExecuteR(QueryInfo *info, char *error, size_t maxlength) =0;
+	};
+
+	class ISQLDriver;
+
+	class IDatabase
+	{
+	public:
+		/** 
+		 * Closes the database and frees the handle.
+		 */
+		virtual void FreeHandle() =0;
+		/**
+		 * Returns the parent driver.
+		 */
+		virtual ISQLDriver *Driver() =0;
+	public:
+		/**
+		 * Query preparation.
+		 */
+		virtual IQuery *PrepareQueryFmt(const char *fmt, ...) =0;
+		virtual IQuery *PrepareQueryFmt(const char *fmt, va_list ap) =0;
+		virtual IQuery *PrepareQuery(const char *query) =0;
+		/**
+		 * Quotes a string properly.
+		 * Returns 0 on success.  On failure, returns
+		 *  the size of the buffer needed, or a negative number
+		 *  on internal failure.
+		 */
+		virtual int QuoteString(const char *str, char buffer[], size_t maxlen, size_t *newsize) =0;
+	};
+
+	struct DatabaseInfo
+	{
+		const char *host;
+		const char *database;
+		const char *user;
+		const char *pass;
+		unsigned int port;
+	};
+
+	class ISQLDriver
+	{
+	public:
+		virtual IDatabase *Connect(DatabaseInfo *info, int *errcode, char *error, size_t maxlength) =0;
+		virtual const char *NameString() =0;
+		virtual bool IsCompatDriver(const char *namestring) =0;
+	};
+};
+
+#endif //_INCLUDE_SOURCEMOD_DATABASE2_H
diff --git a/dlls/sqlite/sqlitepp/SqliteDatabase.cpp b/dlls/sqlite/sqlitepp/SqliteDatabase.cpp
new file mode 100644
index 00000000..39cb02f1
--- /dev/null
+++ b/dlls/sqlite/sqlitepp/SqliteDatabase.cpp
@@ -0,0 +1,80 @@
+#include <stdio.h>
+#include <string.h>
+#include "SqliteDriver.h"
+#include "SqliteDatabase.h"
+#include "SqliteQuery.h"
+
+#if defined WIN32 && !defined vsnprintf
+#define vsnprintf _vsnprintf
+#endif
+
+using namespace SourceMod;
+
+SqliteDatabase::SqliteDatabase(sqlite3 *sql, SqliteDriver *drvr) : 
+	m_pSql(sql), m_pParent(drvr)
+{
+}
+
+SqliteDatabase::~SqliteDatabase()
+{
+	Disconnect();
+}
+
+void SqliteDatabase::Disconnect()
+{
+	if (m_pSql)
+	{
+		sqlite3_close(m_pSql);
+		m_pSql = NULL;
+	}
+}
+
+void SqliteDatabase::FreeHandle()
+{
+	delete this;
+}
+
+ISQLDriver *SqliteDatabase::Driver()
+{
+	return static_cast<ISQLDriver *>(m_pParent);
+}
+
+IQuery *SqliteDatabase::PrepareQuery(const char *query)
+{
+	SqliteQuery *pQuery = new SqliteQuery(this, query);
+	return static_cast<IQuery *>(pQuery);
+}
+
+IQuery *SqliteDatabase::PrepareQueryFmt(const char *fmt, va_list ap)
+{
+	char buffer[4096];
+
+	vsnprintf(buffer, sizeof(buffer)-1, fmt, ap);
+	
+	return PrepareQuery(buffer);
+}
+
+IQuery *SqliteDatabase::PrepareQueryFmt(const char *fmt, ...)
+{
+	va_list ap;
+	IQuery *qry;
+
+	va_start(ap, fmt);
+	qry = PrepareQueryFmt(fmt, ap);
+	va_end(ap);
+
+	return qry;
+}
+
+int SqliteDatabase::QuoteString(const char *str, char buffer[], size_t maxlen, size_t *newsize)
+{
+	unsigned long size = static_cast<unsigned long>(strlen(str));
+	unsigned long needed = size*2 + 1;
+
+	if (size < needed)
+		return (int)needed;
+
+	sqlite3_snprintf(static_cast<int>(maxlen), buffer, "%q", str);
+
+	return 0;
+}
diff --git a/dlls/sqlite/sqlitepp/SqliteDatabase.h b/dlls/sqlite/sqlitepp/SqliteDatabase.h
new file mode 100644
index 00000000..740b8f94
--- /dev/null
+++ b/dlls/sqlite/sqlitepp/SqliteDatabase.h
@@ -0,0 +1,34 @@
+#ifndef _INCLUDE_SOURCEMOD_SQLITE_DATABASE_H
+#define _INCLUDE_SOURCEMOD_SQLITE_DATABASE_H
+
+#include "SqliteHeaders.h"
+#include "SqliteDriver.h"
+
+namespace SourceMod
+{
+	class SqliteDriver;
+
+	class SqliteDatabase : public IDatabase
+	{
+		friend class SqliteQuery;
+	public:
+		SqliteDatabase(sqlite3 *sql, SqliteDriver *drvr);
+		~SqliteDatabase();
+	public:
+		void FreeHandle();
+		ISQLDriver *Driver();
+	public:
+		IQuery *PrepareQueryFmt(const char *fmt, ...);
+		IQuery *PrepareQueryFmt(const char *fmt, va_list ap);
+		IQuery *PrepareQuery(const char *query);
+		int QuoteString(const char *str, char buffer[], size_t maxlen, size_t *newsize);
+	private:
+		void Disconnect();
+	private:
+		sqlite3 *m_pSql;
+		SqliteDriver *m_pParent;
+	};
+};
+
+#endif //_INCLUDE_SOURCEMOD_SQLITE_DATABASE_H
+
diff --git a/dlls/sqlite/sqlitepp/SqliteDriver.cpp b/dlls/sqlite/sqlitepp/SqliteDriver.cpp
new file mode 100644
index 00000000..a65a5ea6
--- /dev/null
+++ b/dlls/sqlite/sqlitepp/SqliteDriver.cpp
@@ -0,0 +1,44 @@
+#include <string.h>
+#include <stdio.h>
+#include "SqliteHeaders.h"
+#include "SqliteDriver.h"
+#include "SqliteDatabase.h"
+
+#if defined WIN32
+#define snprintf _snprintf
+#define strncasecmp strnicmp
+#endif
+
+using namespace SourceMod;
+
+bool SqliteDriver::IsCompatDriver(const char *namestr)
+{
+	return (strncasecmp(namestr, "sqlite", 5) == 0);
+}
+
+const char *SqliteDriver::NameString()
+{
+	return "sqlite";
+}
+
+IDatabase *SqliteDriver::Connect(DatabaseInfo *info, int *errcode, char *error, size_t maxlength)
+{
+	sqlite3 *pSql;
+	int err = sqlite3_open(info->database, &pSql);
+	if (err != SQLITE_OK)
+	{
+		if (errcode)
+		{
+			*errcode = sqlite3_errcode(pSql);
+		}
+		if (error)
+		{
+			snprintf(error, maxlength, "%s", sqlite3_errmsg(pSql));
+		}
+		sqlite3_close(pSql);
+		return NULL;
+	} else {
+		SqliteDatabase *pDb = new SqliteDatabase(pSql, this);
+		return static_cast<IDatabase *>(pDb);
+	}
+}
diff --git a/dlls/sqlite/sqlitepp/SqliteDriver.h b/dlls/sqlite/sqlitepp/SqliteDriver.h
new file mode 100644
index 00000000..7ee2e786
--- /dev/null
+++ b/dlls/sqlite/sqlitepp/SqliteDriver.h
@@ -0,0 +1,17 @@
+#ifndef _INCLUDE_SOURCEMOD_SQLITE_DRIVER_H
+#define _INCLUDE_SOURCEMOD_SQLITE_DRIVER_H
+
+#include "SqliteHeaders.h"
+
+namespace SourceMod
+{
+	class SqliteDriver : public ISQLDriver
+	{
+	public:
+		IDatabase *Connect(DatabaseInfo *info, int *errcode, char *error, size_t maxlength);
+		const char *NameString();
+		bool IsCompatDriver(const char *namestr);
+	};
+};
+
+#endif //_INCLUDE_SOURCEMOD_SQLITE_DRIVER_H
diff --git a/dlls/sqlite/sqlitepp/SqliteHeaders.h b/dlls/sqlite/sqlitepp/SqliteHeaders.h
new file mode 100644
index 00000000..650b78cd
--- /dev/null
+++ b/dlls/sqlite/sqlitepp/SqliteHeaders.h
@@ -0,0 +1,17 @@
+#ifndef _INCLUDE_SOURCEMOD_SQLITE_HEADERS_H
+#define _INCLUDE_SOURCEMOD_SQLITE_HEADERS_H
+
+#if _MSC_VER >= 1400
+	/* disable deprecation warnings */
+	#if !defined _CRT_SECURE_NO_DEPRECATE
+		#define	_CRT_SECURE_NO_DEPRECATE
+	#endif
+
+	#pragma warning (disable:4996)
+#endif //_MSC_VER >= 1400
+
+#include <ISQLDriver.h>
+
+#include "sqlite3.h"
+
+#endif //_INCLUDE_SOURCEMOD_SQLITE_HEADERS_H
diff --git a/dlls/sqlite/sqlitepp/SqliteQuery.cpp b/dlls/sqlite/sqlitepp/SqliteQuery.cpp
new file mode 100644
index 00000000..ca97cdeb
--- /dev/null
+++ b/dlls/sqlite/sqlitepp/SqliteQuery.cpp
@@ -0,0 +1,93 @@
+#include <stdio.h>
+#include <string.h>
+#include "SqliteQuery.h"
+#include "SqliteDatabase.h"
+#include "SqliteResultSet.h"
+
+#if defined WIN32
+#define snprintf _snprintf
+#endif
+
+using namespace SourceMod;
+
+SqliteQuery::SqliteQuery(SqliteDatabase *db, const char *query) : 
+	m_pDatabase(db), m_LastRes(NULL)
+{
+	m_QueryString = new char[strlen(query)+1];
+	strcpy(m_QueryString, query);
+}
+
+SqliteQuery::~SqliteQuery()
+{
+	if (m_LastRes)
+	{
+		m_LastRes->FreeHandle();
+		m_LastRes = NULL;
+	}
+
+	delete [] m_QueryString;
+}
+
+void SqliteQuery::FreeHandle()
+{
+	delete this;
+}
+
+bool SqliteQuery::Execute(QueryInfo *info, char *error, size_t maxlength)
+{
+	bool res = ExecuteR(info, error, maxlength);
+	
+	if (m_LastRes)
+	{
+		m_LastRes->FreeHandle();
+	}
+
+	m_LastRes = (SqliteResultSet *)info->rs;
+
+	return res;
+}
+
+bool SqliteQuery::ExecuteR(QueryInfo *info, char *error, size_t maxlength)
+{
+	int err;
+	char *errmsg;
+	char **results;
+	int rows, cols;
+
+	err = sqlite3_get_table(m_pDatabase->m_pSql, m_QueryString, &results, &rows, &cols, &errmsg);
+
+	if (err != SQLITE_OK)
+	{
+		if (error && maxlength && errmsg)
+		{
+			snprintf(error, maxlength, "%s", errmsg);
+		}
+		info->affected_rows = 0;
+		info->errorcode = err;
+		info->rs = NULL;
+		info->success = false;
+	} else {
+		info->affected_rows = sqlite3_changes(m_pDatabase->m_pSql);
+		info->errorcode = 0;
+		info->success = true;
+		if (cols)
+		{
+			SqliteResults data;
+			data.cols = cols;
+			data.rows = rows;
+			data.results = results;
+
+			SqliteResultSet *pRes = new SqliteResultSet(data);
+			m_LastRes = pRes;
+			info->rs = static_cast<IResultSet *>(pRes);
+		} else {
+			info->rs = NULL;
+			if (results)
+			{
+				sqlite3_free_table(results);
+			}
+		}
+	}
+
+	return info->success;
+}
diff --git a/dlls/sqlite/sqlitepp/SqliteQuery.h b/dlls/sqlite/sqlitepp/SqliteQuery.h
new file mode 100644
index 00000000..0ddd8390
--- /dev/null
+++ b/dlls/sqlite/sqlitepp/SqliteQuery.h
@@ -0,0 +1,34 @@
+#ifndef _INCLUDE_SOURCEMOD_SQLITE_QUERY_H
+#define _INCLUDE_SOURCEMOD_SQLITE_QUERY_H
+
+#include "SqliteHeaders.h"
+
+namespace SourceMod
+{
+	class SqliteDatabase;;
+	class SqliteResultSet;
+
+	class SqliteQuery : public IQuery
+	{
+	public:
+		struct SqliteResults
+		{
+			char **results;
+			int rows;
+			int cols;
+		};
+	public:
+		SqliteQuery(SqliteDatabase *db, const char *query);
+		~SqliteQuery();
+	public:
+		void FreeHandle();
+		bool Execute(QueryInfo *info, char *error, size_t maxlength);
+		bool ExecuteR(QueryInfo *info, char *error, size_t maxlength);
+	private:
+		SqliteDatabase *m_pDatabase;
+		SqliteResultSet *m_LastRes;
+		char *m_QueryString;
+	};
+};
+
+#endif //_INCLUDE_SOURCEMOD_SQLITE_QUERY_H
diff --git a/dlls/sqlite/sqlitepp/SqliteResultSet.cpp b/dlls/sqlite/sqlitepp/SqliteResultSet.cpp
new file mode 100644
index 00000000..c2d08e55
--- /dev/null
+++ b/dlls/sqlite/sqlitepp/SqliteResultSet.cpp
@@ -0,0 +1,160 @@
+#include <string.h>
+#include <stdlib.h>
+#include "SqliteResultSet.h"
+
+using namespace SourceMod;
+
+SqliteResultSet::SqliteResultSet(SqliteQuery::SqliteResults &res)
+{
+	m_pResults = res.results;
+	m_Columns = res.cols;
+	m_Rows = res.rows;
+
+	m_CurRow = 1;
+	m_CurIndex = (m_CurRow * m_Columns);
+}
+
+SqliteResultSet::~SqliteResultSet()
+{
+	if (m_pResults)
+	{
+		sqlite3_free_table(m_pResults);
+		m_pResults = NULL;
+	}
+}
+
+const char *SqliteResultSet::GetStringSafe(unsigned int columnId)
+{
+	if (columnId > m_Columns)
+	{
+		return "";
+	}
+
+	const char *data = m_pResults[m_CurIndex + columnId];
+
+	return data ? data : "";
+}
+
+const char *SqliteResultSet::GetString(unsigned int columnId)
+{
+	if (columnId > m_Columns)
+	{
+		return NULL;
+	}
+
+	return m_pResults[m_CurIndex + columnId];
+}
+
+bool SqliteResultSet::IsNull(unsigned int columnId)
+{
+	return (GetString(columnId) == NULL);
+}
+
+double SqliteResultSet::GetDouble(unsigned int columnId)
+{
+	return atof(GetStringSafe(columnId));
+}
+
+float SqliteResultSet::GetFloat(unsigned int columnId)
+{
+	return (float)atof(GetStringSafe(columnId));
+}
+
+int SqliteResultSet::GetInt(unsigned int columnId)
+{
+	return atoi(GetStringSafe(columnId));
+}
+
+/**
+ * :TODO: - convert this whole beast to sqlite3_prepare/step
+ * that way we get finer control and actual raw/null data.
+ */
+const char *SqliteResultSet::GetRaw(unsigned int columnId, size_t *length)
+{
+	if (columnId >= m_Columns)
+	{
+		if (length)
+		{
+			*length = 0;
+		}
+		return NULL;
+	}
+
+	const char *str = GetString(columnId);
+	if (!str)
+	{
+		if (length)
+		{
+			*length = 0;
+		}
+		return NULL;
+	} else {
+		if (length)
+		{
+			*length = strlen(str);
+		}
+		return str;
+	}
+}
+
+void SqliteResultSet::FreeHandle()
+{
+	delete this;
+}
+
+IResultRow *SqliteResultSet::GetRow()
+{
+	return static_cast<IResultRow *>(this);
+}
+
+unsigned int SqliteResultSet::RowCount()
+{
+	return m_Rows;
+}
+
+const char *SqliteResultSet::FieldNumToName(unsigned int num)
+{
+	if (num >= m_Columns)
+	{
+		return NULL;
+	}
+
+	return m_pResults[num];
+}
+
+bool SqliteResultSet::FieldNameToNum(const char *name, unsigned int *columnId)
+{
+	for (unsigned int i=0; i<m_Columns; i++)
+	{
+		if (strcmp(m_pResults[i], name) == 0)
+		{
+			if (columnId)
+			{
+				*columnId = i;
+			}
+			return true;
+		}
+	}
+
+	if (columnId)
+	{
+		*columnId = -1;
+	}
+
+	return false;
+}
+
+unsigned int SqliteResultSet::FieldCount()
+{
+	return m_Columns;
+}
+
+bool SqliteResultSet::IsDone()
+{
+	return (m_CurRow > m_Rows);
+}
+
+void SqliteResultSet::NextRow()
+{
+	m_CurIndex = (++m_CurRow * m_Columns);
+}
diff --git a/dlls/sqlite/sqlitepp/SqliteResultSet.h b/dlls/sqlite/sqlitepp/SqliteResultSet.h
new file mode 100644
index 00000000..5e8d928c
--- /dev/null
+++ b/dlls/sqlite/sqlitepp/SqliteResultSet.h
@@ -0,0 +1,53 @@
+#ifndef _INCLUDE_SOURCEMOD_SQLITE_RESULTSET_H
+#define _INCLUDE_SOURCEMOD_SQLITE_RESULTSET_H
+
+#include "SqliteHeaders.h"
+#include "SqliteDriver.h"
+#include "SqliteDatabase.h"
+#include "SqliteQuery.h"
+
+namespace SourceMod
+{
+	class SqliteResultSet : public IResultSet, public IResultRow
+	{
+		/** 
+		 * IResultSet
+		 */
+	public:
+		SqliteResultSet(SqliteQuery::SqliteResults &res);
+		~SqliteResultSet();
+	public:
+		void FreeHandle();
+	public: 
+		unsigned int RowCount();
+		unsigned int FieldCount();
+		const char *FieldNumToName(unsigned int num);
+		bool FieldNameToNum(const char *name, unsigned int *columnId);
+	public:
+		bool IsDone();
+		IResultRow *GetRow();
+		void NextRow();
+	public:
+		/** 
+		 * IResultRow
+		 */
+	public:
+		const char *GetString(unsigned int columnId);
+		double GetDouble(unsigned int columnId);
+		float GetFloat(unsigned int columnId);
+		int GetInt(unsigned int columnId);
+		bool IsNull(unsigned int columnId);
+		const char *GetRaw(unsigned int columnId, size_t *length);
+	private:
+		const char *GetStringSafe(unsigned int columnId);
+	private:
+		char **m_pResults;
+		unsigned int m_Columns;
+		unsigned int m_Rows;
+		unsigned int m_CurRow;
+		unsigned int m_CurIndex;
+	};
+};
+
+
+#endif //_INCLUDE_SOURCEMOD_SQLITE_RESULTSET_H
diff --git a/dlls/sqlite/thread/BaseWorker.cpp b/dlls/sqlite/thread/BaseWorker.cpp
new file mode 100644
index 00000000..eb0aa99d
--- /dev/null
+++ b/dlls/sqlite/thread/BaseWorker.cpp
@@ -0,0 +1,249 @@
+#include "BaseWorker.h"
+
+BaseWorker::BaseWorker() : 
+	m_perFrame(SM_DEFAULT_THREADS_PER_FRAME),
+	m_state(Worker_Stopped)
+{
+}
+
+BaseWorker::~BaseWorker()
+{
+	if (m_state != Worker_Stopped || m_state != Worker_Invalid)
+		Stop(true);
+
+	if (m_ThreadQueue.size())
+		Flush(true);
+}
+
+void BaseWorker::MakeThread(IThread *pThread)
+{
+	ThreadParams pt;
+
+	pt.flags = Thread_AutoRelease;
+	pt.prio = ThreadPrio_Normal;
+
+	MakeThread(pThread, &pt);
+}
+
+IThreadHandle *BaseWorker::MakeThread(IThread *pThread, ThreadFlags flags)
+{
+	ThreadParams pt;
+
+	pt.flags = flags;
+	pt.prio = ThreadPrio_Normal;
+
+	return MakeThread(pThread, &pt);
+}
+
+IThreadHandle *BaseWorker::MakeThread(IThread *pThread, const ThreadParams *params)
+{
+	if (m_state != Worker_Running)
+		return NULL;
+
+	SWThreadHandle *swt = new SWThreadHandle(this, params, pThread);
+
+	AddThreadToQueue(swt);
+
+	return swt;
+}
+
+void BaseWorker::GetPriorityBounds(ThreadPriority &max, ThreadPriority &min)
+{
+	max = ThreadPrio_Normal;
+	min = ThreadPrio_Normal;
+}
+
+unsigned int BaseWorker::Flush(bool flush_cancel)
+{
+	SWThreadHandle *swt;
+	unsigned int num = 0;
+
+	while ((swt=PopThreadFromQueue()) != NULL)
+	{
+		swt->m_state = Thread_Done;
+		if (!flush_cancel)
+			swt->pThread->RunThread(swt);
+		swt->pThread->OnTerminate(swt, flush_cancel);
+		if (swt->m_params.flags & Thread_AutoRelease)
+			delete swt;
+		num++;
+	}
+
+	return num;
+}
+
+SWThreadHandle *BaseWorker::PopThreadFromQueue()
+{
+	if (!m_ThreadQueue.size())
+		return NULL;
+
+	SourceHook::List<SWThreadHandle *>::iterator begin;
+	SWThreadHandle *swt;
+
+	begin = m_ThreadQueue.begin();
+	swt = (*begin);
+	m_ThreadQueue.erase(begin);
+
+	return swt;
+}
+
+void BaseWorker::AddThreadToQueue(SWThreadHandle *pHandle)
+{
+	m_ThreadQueue.push_back(pHandle);
+}
+
+unsigned int BaseWorker::GetMaxThreadsPerFrame()
+{
+	return m_perFrame;
+}
+
+WorkerState BaseWorker::GetStatus(unsigned int *threads)
+{
+	if (threads)
+		*threads = m_perFrame;
+
+	return m_state;
+}
+
+unsigned int BaseWorker::RunFrame()
+{
+	unsigned int done = 0;
+	unsigned int max = GetMaxThreadsPerFrame();
+	SWThreadHandle *swt = NULL;
+	IThread *pThread = NULL;
+
+	while (done < max)
+	{
+		if ((swt=PopThreadFromQueue()) == NULL)
+			break;
+		pThread = swt->pThread;
+		swt->m_state = Thread_Running;
+		pThread->RunThread(swt);
+		swt->m_state = Thread_Done;
+		pThread->OnTerminate(swt, false);
+		if (swt->m_params.flags & Thread_AutoRelease)
+			delete swt;
+		done++;
+	}
+
+	return done;
+}
+
+void BaseWorker::SetMaxThreadsPerFrame(unsigned int threads)
+{
+	m_perFrame = threads;
+}
+
+bool BaseWorker::Start()
+{
+	if (m_state != Worker_Invalid && m_state != Worker_Stopped)
+	{
+		return false;
+	}
+
+	m_state = Worker_Running;
+
+    return true;
+}
+
+bool BaseWorker::Stop(bool flush_cancel)
+{
+	if (m_state == Worker_Invalid || m_state == Worker_Stopped)
+		return false;
+
+	if (m_state == Worker_Paused)
+	{
+		if (!Unpause())
+			return false;
+	}
+
+	m_state = Worker_Stopped;
+	Flush(flush_cancel);
+
+	return true;
+}
+
+bool BaseWorker::Pause()
+{
+	if (m_state != Worker_Running)
+		return false;
+
+	m_state = Worker_Paused;
+
+	return true;
+}
+
+
+bool BaseWorker::Unpause()
+{
+	if (m_state != Worker_Paused)
+		return false;
+
+	m_state = Worker_Running;
+
+	return true;
+}
+
+/***********************
+ * THREAD HANDLE STUFF *
+ ***********************/
+
+void SWThreadHandle::DestroyThis()
+{
+	delete this;
+}
+
+void SWThreadHandle::GetParams(ThreadParams *p)
+{
+	*p = m_params;
+}
+
+ThreadPriority SWThreadHandle::GetPriority()
+{
+	return m_params.prio;
+}
+
+ThreadState SWThreadHandle::GetState()
+{
+	return m_state;
+}
+
+IThreadCreator *SWThreadHandle::Parent()
+{
+	return m_parent;
+}
+
+bool SWThreadHandle::SetPriority(ThreadPriority prio)
+{
+	if (m_params.prio != ThreadPrio_Normal)
+		return false;
+
+	m_params.prio = prio;
+
+	return true;
+}
+
+bool SWThreadHandle::Unpause()
+{
+	if (m_state != Thread_Paused)
+		return false;
+
+	m_state = Thread_Running;
+
+	return true;
+}
+
+bool SWThreadHandle::WaitForThread()
+{
+	return false;
+}
+
+SWThreadHandle::SWThreadHandle(IThreadCreator *parent, const ThreadParams *p, IThread *thread) : 
+	m_parent(parent), m_params(*p), pThread(thread), m_state(Thread_Paused)
+{
+}
+
+IThread *SWThreadHandle::GetThread()
+{
+	return pThread;
+}
diff --git a/dlls/sqlite/thread/BaseWorker.h b/dlls/sqlite/thread/BaseWorker.h
new file mode 100644
index 00000000..37b8f5fd
--- /dev/null
+++ b/dlls/sqlite/thread/BaseWorker.h
@@ -0,0 +1,72 @@
+#ifndef _INCLUDE_SOURCEMOD_BASEWORKER_H
+#define _INCLUDE_SOURCEMOD_BASEWORKER_H
+
+#include "sh_list.h"
+#include "ThreadSupport.h"
+
+#define SM_DEFAULT_THREADS_PER_FRAME	1
+
+class BaseWorker;
+
+//SW = Simple Wrapper
+class SWThreadHandle : public IThreadHandle
+{
+	friend class BaseWorker;
+public:
+	SWThreadHandle(IThreadCreator *parent, const ThreadParams *p, IThread *thread);
+	IThread *GetThread();
+public:
+	//NOTE: We don't support this by default.
+	//It's specific usage that'd require many mutexes
+	virtual bool WaitForThread();
+public:
+	virtual void DestroyThis();
+	virtual IThreadCreator *Parent();
+	virtual void GetParams(ThreadParams *ptparams);
+public:
+	//Priorities not supported by default.
+	virtual ThreadPriority GetPriority();
+	virtual bool SetPriority(ThreadPriority prio);
+public:
+	virtual ThreadState GetState();
+	virtual bool Unpause();
+private:
+	ThreadState m_state;
+	ThreadParams m_params;
+	IThreadCreator *m_parent;
+	IThread *pThread;
+};
+
+class BaseWorker : public IWorker
+{
+public:
+	BaseWorker();
+	virtual ~BaseWorker();
+public:	//IWorker
+	virtual unsigned int RunFrame();
+	//Controls the worker
+	virtual bool Pause();
+	virtual bool Unpause();
+	virtual bool Start();
+	virtual bool Stop(bool flush_cancel);
+	//Flushes out any remaining threads
+	virtual unsigned int Flush(bool flush_cancel);
+	//returns status and number of threads in queue
+	virtual WorkerState GetStatus(unsigned int *numThreads);
+public:	//IThreadCreator
+	virtual void MakeThread(IThread *pThread);
+	virtual IThreadHandle *MakeThread(IThread *pThread, ThreadFlags flags);
+	virtual IThreadHandle *MakeThread(IThread *pThread, const ThreadParams *params);
+	virtual void GetPriorityBounds(ThreadPriority &max, ThreadPriority &min);
+public:	//BaseWorker
+	virtual void AddThreadToQueue(SWThreadHandle *pHandle);
+	virtual SWThreadHandle *PopThreadFromQueue();
+	virtual void SetMaxThreadsPerFrame(unsigned int threads);
+	virtual unsigned int GetMaxThreadsPerFrame();
+protected:
+	SourceHook::List<SWThreadHandle *> m_ThreadQueue;
+	unsigned int m_perFrame;
+	volatile WorkerState m_state;
+};
+
+#endif //_INCLUDE_SOURCEMOD_BASEWORKER_H
diff --git a/dlls/sqlite/thread/IThreader.h b/dlls/sqlite/thread/IThreader.h
new file mode 100644
index 00000000..27d0aa32
--- /dev/null
+++ b/dlls/sqlite/thread/IThreader.h
@@ -0,0 +1,222 @@
+#ifndef _INCLUDE_SOURCEMOD_THREADER_H
+#define _INCLUDE_SOURCEMOD_THREADER_H
+
+namespace SourceMod
+{
+	enum ThreadFlags
+	{
+		Thread_Default = 0,
+		//auto release handle on finish
+		//you are not guaranteed the handle for this is valid after
+		// calling MakeThread(), so never use it until OnTerminate is called.
+		Thread_AutoRelease = 1,
+		//Thread is created "suspended", meaning
+		// it is inactive until unpaused.
+		Thread_CreateSuspended = 2,
+	};
+
+	enum ThreadPriority
+	{
+		ThreadPrio_Minimum = -8,
+		ThreadPrio_Low = -3,
+		ThreadPrio_Normal = 0,
+		ThreadPrio_High = 3,
+		ThreadPrio_Maximum = 8,
+	};
+
+	enum ThreadState
+	{
+		Thread_Running = 0,
+		Thread_Paused = 1,
+		Thread_Done = 2,
+	};
+
+	struct ThreadParams
+	{
+		ThreadParams() : 
+			flags(Thread_Default), 
+			prio(ThreadPrio_Normal)
+		{
+		};
+		ThreadFlags flags;
+		ThreadPriority prio;
+	};
+
+	class IThreadCreator;
+
+	/**
+	 * Describes a handle to a thread
+	 */
+	class IThreadHandle
+	{
+	public:
+		virtual ~IThreadHandle() { };
+	public:
+		/**
+		 * Pauses parent thread until this thread completes.
+		 */
+		virtual bool WaitForThread() =0;
+		/**
+		 * Destroys the thread handle.
+		 * This will not necessarily cancel the thread.
+		 */
+		virtual void DestroyThis() =0;
+		/**
+		 * Returns the parent threader.
+		 */
+		virtual IThreadCreator *Parent() =0;
+		/**
+		 * Returns the thread states.
+		 */
+		virtual void GetParams(ThreadParams *ptparams) =0;
+		/**
+		 * Returns priority
+		 */
+		virtual ThreadPriority GetPriority() =0;
+		/**
+		 * Sets thread priority
+		 */
+		virtual bool SetPriority(ThreadPriority prio) =0;
+		/**
+		 * Gets thread state
+		 */
+		virtual ThreadState GetState() =0;
+		/**
+		 * Attempts to unpause a paused thread.
+		 */
+		virtual bool Unpause() =0;
+	};
+
+	/**
+	 * Describes a single unit of execution/context flow
+	 */
+	class IThread
+	{
+	public:
+		//Called when the thread runs
+		virtual void RunThread(IThreadHandle *pHandle) =0;
+		//Called when the thread terminates.
+		//"Cancel" is true if the thread did not finish
+		//(this could mean suspended or terminated abruptly)
+		virtual void OnTerminate(IThreadHandle *pHandle, bool cancel) =0;
+	};
+
+
+	/**
+	 * Describes a thread creator
+	 */
+	class IThreadCreator
+	{
+	public:
+		//Makes a thread and cleans up the handle for you
+		virtual void MakeThread(IThread *pThread) =0;
+		//Makes a thread with flag specified
+		virtual IThreadHandle *MakeThread(IThread *pThread, ThreadFlags flags) =0;
+		//Makes a thread, full options can be specified
+		virtual IThreadHandle *MakeThread(IThread *pThread, const ThreadParams *params) =0;
+		//Return priority bounds
+		virtual void GetPriorityBounds(ThreadPriority &max, ThreadPriority &min) =0;
+	};
+
+	/**
+	 * Basic Mutex
+	 */
+	class IMutex
+	{
+	public:
+		virtual ~IMutex() { };
+	public:
+		/**
+		 * Attempts to lock, but returns instantly.
+		 */
+		virtual bool TryLock() =0;
+		/**
+ 		 * Attempts to lock by waiting for release.
+		 */
+		virtual void Lock() =0;
+		/**
+		 * Unlocks mutex.
+		 */
+		virtual void Unlock() =0;
+		/**
+		 * Frees the mutex handle.
+		 */
+		virtual void DestroyThis() =0;
+	};
+
+
+	class IEventSignal
+	{
+	public:
+		/**
+		 * Waits for the signal.
+		 */
+		virtual void Wait() =0;
+		/** 
+		 * Triggers the signal.
+		 * Resets the signals after triggering.
+		 */
+		virtual void Signal() =0;
+		/**
+		 * Frees the signal handle.
+		 */
+		virtual void DestroyThis() =0;
+	};
+
+	/**
+	 * Describes a threading system
+	 */
+	class IThreader : public IThreadCreator
+	{
+	public:
+		virtual IMutex *MakeMutex() =0;
+		virtual void MakeThread(IThread *pThread) =0;
+		virtual IThreadHandle *MakeThread(IThread *pThread, ThreadFlags flags) =0;
+		virtual IThreadHandle *MakeThread(IThread *pThread, const ThreadParams *params) =0;
+		virtual void GetPriorityBounds(ThreadPriority &max, ThreadPriority &min) =0;
+		virtual void ThreadSleep(unsigned int ms) =0;
+		/**
+		 * Creates a non-signalled event.
+		 */
+		virtual IEventSignal *MakeEventSignal() =0;
+	};
+
+	enum WorkerState
+	{
+		Worker_Invalid = -3,
+		Worker_Stopped = -2,
+		Worker_Paused = -1,
+		Worker_Running,
+	};
+
+	/**
+	 * This is an extension of the threader that is implemented.
+	 * It "simulates" threading in a queue, and processes the queue whenever
+	 *  RunFrame is called (leaving it up to the implementation).
+	 * Worker may or may not be started upon instantiation.
+	 */
+	class IWorker : public IThreadCreator
+	{
+	public:
+		virtual unsigned int RunFrame() =0;
+		virtual void MakeThread(IThread *pThread) =0;
+		virtual IThreadHandle *MakeThread(IThread *pThread, ThreadFlags flags) =0;
+		virtual IThreadHandle *MakeThread(IThread *pThread, const ThreadParams *params) =0;
+		virtual void GetPriorityBounds(ThreadPriority &max, ThreadPriority &min) =0;
+	public:
+		//Controls the worker
+		virtual bool Pause() =0;
+		virtual bool Unpause() =0;
+		virtual bool Start() =0;
+		//If flush is true, all remaining tasks will be cancelled.
+		//Otherwise, it will wait until the tasks have been depleted, then
+		// end.
+		virtual bool Stop(bool flush_cancel) =0;
+		//Flushes out any remaining threads
+		virtual unsigned int Flush(bool flush_cancel) =0;
+		//returns status and number of threads in queue
+		virtual WorkerState GetStatus(unsigned int *numThreads) =0;
+	};
+};
+
+#endif //_INCLUDE_SOURCEMOD_THREADER_H
diff --git a/dlls/sqlite/thread/PosixThreads.cpp b/dlls/sqlite/thread/PosixThreads.cpp
new file mode 100644
index 00000000..874faa11
--- /dev/null
+++ b/dlls/sqlite/thread/PosixThreads.cpp
@@ -0,0 +1,263 @@
+#include <unistd.h>
+#include "PosixThreads.h"
+
+void PosixThreader::ThreadSleep(unsigned int ms)
+{
+	usleep( ms * 1000 );
+}
+
+void PosixThreader::GetPriorityBounds(ThreadPriority &max, ThreadPriority &min)
+{
+	max = ThreadPrio_Normal;
+	min = ThreadPrio_Normal;
+}
+
+IMutex *PosixThreader::MakeMutex()
+{
+	pthread_mutex_t mutex;
+
+	if (pthread_mutex_init(&mutex, NULL) != 0)
+		return NULL;
+
+	PosixMutex *pMutex = new PosixMutex(mutex);
+
+	return pMutex;
+}
+
+
+void PosixThreader::MakeThread(IThread *pThread)
+{
+	ThreadParams defparams;
+
+	defparams.flags = Thread_AutoRelease;
+	defparams.prio = ThreadPrio_Normal;
+
+	MakeThread(pThread, &defparams);
+}
+
+IThreadHandle *PosixThreader::MakeThread(IThread *pThread, ThreadFlags flags)
+{
+	ThreadParams defparams;
+
+	defparams.flags = flags;
+	defparams.prio = ThreadPrio_Normal;
+
+	return MakeThread(pThread, &defparams);
+}
+
+void *Posix_ThreadGate(void *param)
+{
+	PosixThreader::ThreadHandle *pHandle = 
+		reinterpret_cast<PosixThreader::ThreadHandle *>(param);
+
+	//Block this thread from being started initially.
+	pthread_mutex_lock(&pHandle->m_runlock);
+	//if we get here, we've obtained the lock and are allowed to run.
+	//unlock and continue.
+	pthread_mutex_unlock(&pHandle->m_runlock);
+
+	pHandle->m_run->RunThread(pHandle);
+
+	ThreadParams params;
+	pthread_mutex_lock(&pHandle->m_statelock);
+	pHandle->m_state = Thread_Done;
+	pHandle->GetParams(&params);
+	pthread_mutex_unlock(&pHandle->m_statelock);
+
+	pHandle->m_run->OnTerminate(pHandle, false);
+	if (params.flags & Thread_AutoRelease)
+		delete pHandle;
+
+	return 0;
+}
+
+ThreadParams g_defparams;
+IThreadHandle *PosixThreader::MakeThread(IThread *pThread, const ThreadParams *params)
+{
+	if (params == NULL)
+		params = &g_defparams;
+
+	PosixThreader::ThreadHandle *pHandle = 
+		new PosixThreader::ThreadHandle(this, pThread, params);
+
+	pthread_mutex_lock(&pHandle->m_runlock);
+
+	int err;
+	err = pthread_create(&pHandle->m_thread, NULL, Posix_ThreadGate, (void *)pHandle);	
+
+	if (err != 0)
+	{
+		pthread_mutex_unlock(&pHandle->m_runlock);
+		delete pHandle;
+		return NULL;
+	}
+
+	//Don't bother setting priority...
+
+	if (!(pHandle->m_params.flags & Thread_CreateSuspended))
+	{
+		pHandle->m_state = Thread_Running;
+		err = pthread_mutex_unlock(&pHandle->m_runlock);
+		if (err != 0)
+			pHandle->m_state = Thread_Paused;
+	}
+
+	return pHandle;
+}
+
+IEventSignal *PosixThreader::MakeEventSignal()
+{
+	return new PosixEventSignal();
+}
+
+/*****************
+**** Mutexes ****
+*****************/
+
+PosixThreader::PosixMutex::~PosixMutex()
+{
+	pthread_mutex_destroy(&m_mutex);
+}
+
+bool PosixThreader::PosixMutex::TryLock()
+{
+	int err = pthread_mutex_trylock(&m_mutex);
+
+	return (err == 0);
+}
+
+void PosixThreader::PosixMutex::Lock()
+{
+	pthread_mutex_lock(&m_mutex);
+}
+
+void PosixThreader::PosixMutex::Unlock()
+{
+	pthread_mutex_unlock(&m_mutex);
+}
+
+void PosixThreader::PosixMutex::DestroyThis()
+{
+	delete this;
+}
+
+/******************
+* Thread Handles *
+******************/
+
+PosixThreader::ThreadHandle::ThreadHandle(IThreader *parent, IThread *run, const ThreadParams *params) : 
+	m_parent(parent), m_run(run), m_params(*params), m_state(Thread_Paused)
+{
+	pthread_mutex_init(&m_runlock, NULL);
+	pthread_mutex_init(&m_statelock, NULL);
+}
+
+PosixThreader::ThreadHandle::~ThreadHandle()
+{
+	pthread_mutex_destroy(&m_runlock);
+	pthread_mutex_destroy(&m_statelock);
+}
+
+bool PosixThreader::ThreadHandle::WaitForThread()
+{
+	void *arg;
+	
+	if (pthread_join(m_thread, &arg) != 0)
+		return false;
+
+	return true;
+}
+
+ThreadState PosixThreader::ThreadHandle::GetState()
+{
+	ThreadState state;
+
+	pthread_mutex_lock(&m_statelock);
+	state = m_state;
+	pthread_mutex_unlock(&m_statelock);
+
+	return state;
+}
+
+IThreadCreator *PosixThreader::ThreadHandle::Parent()
+{
+	return m_parent;
+}
+
+void PosixThreader::ThreadHandle::DestroyThis()
+{
+	if (m_params.flags & Thread_AutoRelease)
+		return;
+
+	delete this;
+}
+
+void PosixThreader::ThreadHandle::GetParams(ThreadParams *ptparams)
+{
+	if (!ptparams)
+		return;
+
+	*ptparams = m_params;
+}
+
+ThreadPriority PosixThreader::ThreadHandle::GetPriority()
+{
+	return ThreadPrio_Normal;
+}
+
+bool PosixThreader::ThreadHandle::SetPriority(ThreadPriority prio)
+{
+	return (prio == ThreadPrio_Normal);
+}
+
+bool PosixThreader::ThreadHandle::Unpause()
+{
+	if (m_state != Thread_Paused)
+		return false;
+
+	m_state = Thread_Running;
+
+	if (pthread_mutex_unlock(&m_runlock) != 0)
+	{
+		m_state = Thread_Paused;
+		return false;
+	}
+
+	return true;
+}
+
+/*****************
+ * EVENT SIGNALS *
+ *****************/
+
+PosixThreader::PosixEventSignal::PosixEventSignal()
+{
+	pthread_cond_init(&m_cond, NULL);
+	pthread_mutex_init(&m_mutex, NULL);
+}
+
+PosixThreader::PosixEventSignal::~PosixEventSignal()
+{
+	pthread_cond_destroy(&m_cond);
+	pthread_mutex_destroy(&m_mutex);
+}
+
+void PosixThreader::PosixEventSignal::Wait()
+{
+	pthread_mutex_lock(&m_mutex);
+	pthread_cond_wait(&m_cond, &m_mutex);
+	pthread_mutex_unlock(&m_mutex);
+}
+
+void PosixThreader::PosixEventSignal::Signal()
+{
+	pthread_mutex_lock(&m_mutex);
+	pthread_cond_broadcast(&m_cond);
+	pthread_mutex_unlock(&m_mutex);
+}
+
+void PosixThreader::PosixEventSignal::DestroyThis()
+{
+        delete this;
+}
+
diff --git a/dlls/sqlite/thread/PosixThreads.h b/dlls/sqlite/thread/PosixThreads.h
new file mode 100644
index 00000000..95245d79
--- /dev/null
+++ b/dlls/sqlite/thread/PosixThreads.h
@@ -0,0 +1,82 @@
+#ifndef _INCLUDE_POSIXTHREADS_H_
+#define _INCLUDE_POSIXTHREADS_H_
+
+#include <pthread.h>
+#include "IThreader.h"
+
+using namespace SourceMod;
+
+void *Posix_ThreadGate(void *param);
+
+class PosixThreader : public IThreader
+{
+public:
+	class ThreadHandle : public IThreadHandle
+	{
+		friend class PosixThreader;
+		friend void *Posix_ThreadGate(void *param);
+	public:
+		ThreadHandle(IThreader *parent, IThread *run, const ThreadParams *params);
+		virtual ~ThreadHandle();
+	public:
+		virtual bool WaitForThread();
+		virtual void DestroyThis();
+		virtual IThreadCreator *Parent();
+		virtual void GetParams(ThreadParams *ptparams);
+		virtual ThreadPriority GetPriority();
+		virtual bool SetPriority(ThreadPriority prio);
+		virtual ThreadState GetState();
+		virtual bool Unpause();
+	protected:
+		IThreader *m_parent;		//Parent handle
+		pthread_t m_thread;			//Windows HANDLE	
+		ThreadParams m_params;		//Current Parameters
+		IThread *m_run;	//Runnable context
+		pthread_mutex_t m_statelock;
+		pthread_mutex_t m_runlock;
+		ThreadState m_state;		//internal state
+	};
+	class PosixMutex : public IMutex
+	{
+	public:
+		PosixMutex(pthread_mutex_t m) : m_mutex(m)
+		{
+		};
+		virtual ~PosixMutex();
+	public:
+		virtual bool TryLock();
+		virtual void Lock();
+		virtual void Unlock();
+		virtual void DestroyThis();
+	protected:
+		pthread_mutex_t m_mutex;
+	};
+	class PosixEventSignal : public IEventSignal
+	{
+	public:
+		PosixEventSignal();
+		virtual ~PosixEventSignal();
+	public:
+		virtual void Wait();
+		virtual void Signal();
+		virtual void DestroyThis();
+	protected:
+		pthread_cond_t m_cond;
+		pthread_mutex_t m_mutex;
+	};
+public:
+	virtual IMutex *MakeMutex();
+	virtual void MakeThread(IThread *pThread);
+	virtual IThreadHandle *MakeThread(IThread *pThread, ThreadFlags flags);
+	virtual IThreadHandle *MakeThread(IThread *pThread, const ThreadParams *params);
+	virtual void GetPriorityBounds(ThreadPriority &max, ThreadPriority &min);
+	virtual void ThreadSleep(unsigned int ms);
+	virtual IEventSignal *MakeEventSignal();
+};
+
+#if defined SM_DEFAULT_THREADER && !defined SM_MAIN_THREADER
+#define SM_MAIN_THREADER PosixThreader;
+typedef class PosixThreader MainThreader;
+#endif
+
+#endif //_INCLUDE_POSIXTHREADS_H_
diff --git a/dlls/sqlite/thread/ThreadSupport.h b/dlls/sqlite/thread/ThreadSupport.h
new file mode 100644
index 00000000..40e3ff0c
--- /dev/null
+++ b/dlls/sqlite/thread/ThreadSupport.h
@@ -0,0 +1,10 @@
+#ifndef _INCLUDE_SOURCEMOD_THREAD_SUPPORT_H
+#define _INCLUDE_SOURCEMOD_THREAD_SUPPORT_H
+
+#if defined __linux__
+#include "PosixThreads.h"
+#elif defined WIN32
+#include "WinThreads.h"
+#endif
+
+#endif //_INCLUDE_SOURCEMOD_THREAD_SUPPORT_H
diff --git a/dlls/sqlite/thread/ThreadWorker.cpp b/dlls/sqlite/thread/ThreadWorker.cpp
new file mode 100644
index 00000000..daff21ed
--- /dev/null
+++ b/dlls/sqlite/thread/ThreadWorker.cpp
@@ -0,0 +1,245 @@
+#include "ThreadWorker.h"
+
+ThreadWorker::ThreadWorker() : 
+	m_Threader(NULL),
+	m_QueueLock(NULL),
+	m_StateLock(NULL),
+	m_PauseSignal(NULL),
+	m_AddSignal(NULL),
+	me(NULL),
+	m_think_time(DEFAULT_THINK_TIME_MS)
+{
+	m_state = Worker_Invalid;
+}
+
+ThreadWorker::ThreadWorker(IThreader *pThreader, unsigned int thinktime) : 
+	m_Threader(pThreader),
+	m_QueueLock(NULL),
+	m_StateLock(NULL),
+	m_PauseSignal(NULL),
+	m_AddSignal(NULL),
+	me(NULL),
+	m_think_time(thinktime)
+{
+	if (m_Threader)
+	{
+		m_state = Worker_Stopped;
+	} else {
+		m_state = Worker_Invalid;
+	}
+}
+
+ThreadWorker::~ThreadWorker()
+{
+	if (m_state != Worker_Stopped || m_state != Worker_Invalid)
+		Stop(true);
+
+	if (m_ThreadQueue.size())
+		Flush(true);
+}
+
+void ThreadWorker::OnTerminate(IThreadHandle *pHandle, bool cancel)
+{
+	//we don't particularly care
+	return;
+}
+
+void ThreadWorker::RunThread(IThreadHandle *pHandle)
+{
+	WorkerState this_state = Worker_Running;
+	size_t num;
+    
+	while (true)
+	{
+		/**
+		 * Check number of items in the queue
+		 */
+		if (this_state != Worker_Stopped)
+		{
+			m_QueueLock->Lock();
+			num = m_ThreadQueue.size();
+			if (!num)
+			{
+				/** 
+				 * if none, wait for an item
+				 */
+				m_Waiting = true;
+				m_QueueLock->Unlock();
+				m_AddSignal->Wait();
+				m_Waiting = false;
+			} else {
+				m_QueueLock->Unlock();
+			}
+		}
+		m_StateLock->Lock();
+		this_state = m_state;
+		m_StateLock->Unlock();
+		if (this_state != Worker_Running)
+		{
+			if (this_state == Worker_Paused || this_state == Worker_Stopped)
+			{
+				//wait until the lock is cleared.
+				if (this_state == Worker_Paused)
+					m_PauseSignal->Wait();
+				if (this_state == Worker_Stopped)
+				{
+					//if we're supposed to flush cleanrly, 
+					// run all of the remaining frames first.
+					if (!m_FlushType)
+					{
+						while (m_ThreadQueue.size())
+							RunFrame();
+					}
+					break;
+				}
+			}
+		}
+		/**
+		 * Run the frame.
+		 */
+		RunFrame();
+
+		/**
+		 * wait in between threads if specified
+		 */
+		if (m_think_time)
+			m_Threader->ThreadSleep(m_think_time);
+	}
+}
+
+SWThreadHandle *ThreadWorker::PopThreadFromQueue()
+{
+	if (m_state <= Worker_Stopped && !m_QueueLock)
+		return NULL;
+
+	SWThreadHandle *swt;
+	m_QueueLock->Lock();
+	swt = BaseWorker::PopThreadFromQueue();
+	m_QueueLock->Unlock();
+
+	return swt;
+}
+
+void ThreadWorker::AddThreadToQueue(SWThreadHandle *pHandle)
+{
+	if (m_state <= Worker_Stopped)
+		return;
+
+	m_QueueLock->Lock();
+	BaseWorker::AddThreadToQueue(pHandle);
+	if (m_Waiting)
+	{
+		m_AddSignal->Signal();
+	}
+	m_QueueLock->Unlock();
+}
+
+WorkerState ThreadWorker::GetStatus(unsigned int *threads)
+{
+	WorkerState state;
+
+	m_StateLock->Lock();
+	state = BaseWorker::GetStatus(threads);
+	m_StateLock->Unlock();
+
+	return state;
+}
+
+bool ThreadWorker::Start()
+{
+	if (m_state == Worker_Invalid)
+	{
+		if (m_Threader == NULL)
+			return false;
+	} else if (m_state != Worker_Stopped) {
+		return false;
+	}
+
+	m_Waiting = false;
+	m_QueueLock = m_Threader->MakeMutex();
+	m_StateLock = m_Threader->MakeMutex();
+	m_PauseSignal = m_Threader->MakeEventSignal();
+	m_AddSignal = m_Threader->MakeEventSignal();
+	m_state = Worker_Running;
+	ThreadParams pt;
+	pt.flags = Thread_Default;
+	pt.prio = ThreadPrio_Normal;
+	me = m_Threader->MakeThread(this, &pt);
+
+	return true;
+}
+
+bool ThreadWorker::Stop(bool flush_cancel)
+{
+	if (m_state == Worker_Invalid || m_state == Worker_Stopped)
+		return false;
+
+	WorkerState oldstate;
+
+	//set new state
+	m_StateLock->Lock();
+	oldstate = m_state;
+	m_state = Worker_Stopped;
+	m_FlushType = flush_cancel;
+	m_StateLock->Unlock();
+
+	if (oldstate == Worker_Paused)
+	{
+		Unpause();
+	} else {
+		m_AddSignal->Signal();
+		Pause();
+		Unpause();
+	}
+
+	me->WaitForThread();
+	//destroy it
+	me->DestroyThis();
+	//flush all remaining events
+	Flush(true);
+
+	//free mutex locks
+	m_QueueLock->DestroyThis();
+	m_StateLock->DestroyThis();
+	m_PauseSignal->DestroyThis();
+	m_AddSignal->DestroyThis();
+
+	//invalidizzle
+	m_QueueLock = NULL;
+	m_StateLock = NULL;
+	m_PauseSignal = NULL;
+	m_AddSignal = NULL;
+	me = NULL;
+
+	return true;
+}
+
+bool ThreadWorker::Pause()
+{
+	if (m_state != Worker_Running)
+		return false;
+
+	m_StateLock->Lock();
+	m_state = Worker_Paused;
+	m_StateLock->Unlock();
+
+	return true;
+}
+
+
+bool ThreadWorker::Unpause()
+{
+	if (m_state != Worker_Paused)
+		return false;
+
+	m_StateLock->Lock();
+	m_state = Worker_Running;
+	m_StateLock->Unlock();
+	m_PauseSignal->Signal();
+	if (m_Waiting)
+	{
+		m_AddSignal->Signal();
+	}
+
+	return true;
+}
diff --git a/dlls/sqlite/thread/ThreadWorker.h b/dlls/sqlite/thread/ThreadWorker.h
new file mode 100644
index 00000000..a8c57be3
--- /dev/null
+++ b/dlls/sqlite/thread/ThreadWorker.h
@@ -0,0 +1,40 @@
+#ifndef _INCLUDE_SOURCEMOD_THREADWORKER_H
+#define _INCLUDE_SOURCEMOD_THREADWORKER_H
+
+#include "BaseWorker.h"
+
+#define DEFAULT_THINK_TIME_MS	500
+
+class ThreadWorker : public BaseWorker, public IThread
+{
+public:
+	ThreadWorker();
+	ThreadWorker(IThreader *pThreader, unsigned int thinktime=DEFAULT_THINK_TIME_MS);
+	virtual ~ThreadWorker();
+public:	//IThread
+	virtual void OnTerminate(IThreadHandle *pHandle, bool cancel);
+	virtual void RunThread(IThreadHandle *pHandle);
+public:	//IWorker
+	//Controls the worker
+	virtual bool Pause();
+	virtual bool Unpause();
+	virtual bool Start();
+	virtual bool Stop(bool flush_cancel);
+	//returns status and number of threads in queue
+	virtual WorkerState GetStatus(unsigned int *numThreads);
+public:	//BaseWorker
+	virtual void AddThreadToQueue(SWThreadHandle *pHandle);
+	virtual SWThreadHandle *PopThreadFromQueue();
+protected:
+	IThreader *m_Threader;
+	IMutex *m_QueueLock;
+	IMutex *m_StateLock;
+	IEventSignal *m_PauseSignal;
+	IEventSignal *m_AddSignal;
+	IThreadHandle *me;
+	unsigned int m_think_time;
+	volatile bool m_Waiting;
+	volatile bool m_FlushType;
+};
+
+#endif //_INCLUDE_SOURCEMOD_THREADWORKER_H
diff --git a/dlls/sqlite/thread/WinThreads.cpp b/dlls/sqlite/thread/WinThreads.cpp
new file mode 100644
index 00000000..6f3f436f
--- /dev/null
+++ b/dlls/sqlite/thread/WinThreads.cpp
@@ -0,0 +1,289 @@
+#include "WinThreads.h"
+
+void WinThreader::ThreadSleep(unsigned int ms)
+{
+	Sleep((DWORD)ms);
+}
+
+IMutex *WinThreader::MakeMutex()
+{
+	HANDLE mutex = CreateMutexA(NULL, FALSE, NULL);
+
+	if (mutex == NULL)
+		return NULL;
+
+	WinMutex *pMutex = new WinMutex(mutex);
+
+	return pMutex;
+}
+
+IThreadHandle *WinThreader::MakeThread(IThread *pThread, ThreadFlags flags)
+{
+	ThreadParams defparams;
+
+	defparams.flags = flags;
+	defparams.prio = ThreadPrio_Normal;
+
+	return MakeThread(pThread, &defparams);
+}
+
+void WinThreader::MakeThread(IThread *pThread)
+{
+	ThreadParams defparams;
+
+	defparams.flags = Thread_AutoRelease;
+	defparams.prio = ThreadPrio_Normal;
+
+	MakeThread(pThread, &defparams);
+}
+
+DWORD WINAPI Win32_ThreadGate(LPVOID param)
+{
+	WinThreader::ThreadHandle *pHandle = 
+		reinterpret_cast<WinThreader::ThreadHandle *>(param);
+
+	pHandle->m_run->RunThread(pHandle);
+
+	ThreadParams params;
+	EnterCriticalSection(&pHandle->m_crit);
+	pHandle->m_state = Thread_Done;
+	pHandle->GetParams(&params);
+	LeaveCriticalSection(&pHandle->m_crit);
+
+	pHandle->m_run->OnTerminate(pHandle, false);
+	if (params.flags & Thread_AutoRelease)
+		delete pHandle;
+
+	return 0;
+}
+
+void WinThreader::GetPriorityBounds(ThreadPriority &max, ThreadPriority &min)
+{
+	max = ThreadPrio_Maximum;
+	min = ThreadPrio_Minimum;
+}
+
+ThreadParams g_defparams;
+IThreadHandle *WinThreader::MakeThread(IThread *pThread, const ThreadParams *params)
+{
+	if (params == NULL)
+		params = &g_defparams;
+
+	WinThreader::ThreadHandle *pHandle = 
+		new WinThreader::ThreadHandle(this, NULL, pThread, params);
+
+	DWORD tid;
+	pHandle->m_thread = 
+		CreateThread(NULL, 0, &Win32_ThreadGate, (LPVOID)pHandle, CREATE_SUSPENDED, &tid);
+
+	if (!pHandle->m_thread)
+	{
+		delete pHandle;
+		return NULL;
+	}
+
+	if (pHandle->m_params.prio != ThreadPrio_Normal)
+	{
+		pHandle->SetPriority(pHandle->m_params.prio);
+	}
+
+	if (!(pHandle->m_params.flags & Thread_CreateSuspended))
+	{
+		pHandle->Unpause();
+	}
+
+	return pHandle;
+}
+
+IEventSignal *WinThreader::MakeEventSignal()
+{
+	HANDLE event = CreateEventA(NULL, FALSE, FALSE, NULL);
+
+	if (!event)
+		return NULL;
+
+	WinEvent *pEvent = new WinEvent(event);
+
+	return pEvent;
+}
+
+/*****************
+ **** Mutexes ****
+ *****************/
+
+WinThreader::WinMutex::~WinMutex()
+{
+	if (m_mutex)
+	{
+		CloseHandle(m_mutex);
+		m_mutex = NULL;
+	}
+}
+
+bool WinThreader::WinMutex::TryLock()
+{
+	if (!m_mutex)
+		return false;
+
+	if (WaitForSingleObject(m_mutex, 0) != WAIT_FAILED)
+		return true;
+
+	return false;
+}
+
+void WinThreader::WinMutex::Lock()
+{
+	if (!m_mutex)
+		return;
+
+	WaitForSingleObject(m_mutex, INFINITE);
+}
+
+void WinThreader::WinMutex::Unlock()
+{
+	if (!m_mutex)
+		return;
+
+	ReleaseMutex(m_mutex);
+}
+
+void WinThreader::WinMutex::DestroyThis()
+{
+	delete this;
+}
+
+/******************
+ * Thread Handles *
+ ******************/
+
+WinThreader::ThreadHandle::ThreadHandle(IThreader *parent, HANDLE hthread, IThread *run, const ThreadParams *params) : 
+	m_parent(parent), m_thread(hthread), m_run(run), m_params(*params),
+	m_state(Thread_Paused)
+{
+	InitializeCriticalSection(&m_crit);
+}
+
+WinThreader::ThreadHandle::~ThreadHandle()
+{
+	if (m_thread)
+	{
+		CloseHandle(m_thread);
+		m_thread = NULL;
+	}
+	DeleteCriticalSection(&m_crit);
+}
+
+bool WinThreader::ThreadHandle::WaitForThread()
+{
+	if (m_thread == NULL)
+		return false;
+
+	if (WaitForSingleObject(m_thread, INFINITE) != 0)
+		return false;
+
+	return true;
+}
+
+ThreadState WinThreader::ThreadHandle::GetState()
+{
+	ThreadState state;
+
+	EnterCriticalSection(&m_crit);
+	state = m_state;
+	LeaveCriticalSection(&m_crit);
+
+	return state;
+}
+
+IThreadCreator *WinThreader::ThreadHandle::Parent()
+{
+	return m_parent;
+}
+
+void WinThreader::ThreadHandle::DestroyThis()
+{
+	if (m_params.flags & Thread_AutoRelease)
+		return;
+
+	delete this;
+}
+
+void WinThreader::ThreadHandle::GetParams(ThreadParams *ptparams)
+{
+	if (!ptparams)
+		return;
+
+	*ptparams = m_params;
+}
+
+ThreadPriority WinThreader::ThreadHandle::GetPriority()
+{
+	return m_params.prio;
+}
+
+bool WinThreader::ThreadHandle::SetPriority(ThreadPriority prio)
+{
+	if (!m_thread)
+		return false;
+
+	BOOL res = FALSE;
+
+	if (prio >= ThreadPrio_Maximum)
+		res = SetThreadPriority(m_thread, THREAD_PRIORITY_HIGHEST);
+	else if (prio <= ThreadPrio_Minimum)
+		res = SetThreadPriority(m_thread, THREAD_PRIORITY_LOWEST);
+	else if (prio == ThreadPrio_Normal)
+		res = SetThreadPriority(m_thread, THREAD_PRIORITY_NORMAL);
+	else if (prio == ThreadPrio_High)
+		res = SetThreadPriority(m_thread, THREAD_PRIORITY_ABOVE_NORMAL);
+	else if (prio == ThreadPrio_Low)
+		res = SetThreadPriority(m_thread, THREAD_PRIORITY_BELOW_NORMAL);
+
+	m_params.prio = prio;
+
+	return (res != FALSE);
+}
+
+bool WinThreader::ThreadHandle::Unpause()
+{
+	if (!m_thread)
+		return false;
+
+	if (m_state != Thread_Paused)
+		return false;
+
+	m_state = Thread_Running;
+
+	if (ResumeThread(m_thread) == -1)
+	{
+		m_state = Thread_Paused;
+		return false;
+	}
+
+	return true;
+}
+
+/*****************
+ * EVENT SIGNALS *
+ *****************/
+
+WinThreader::WinEvent::~WinEvent()
+{
+	CloseHandle(m_event);
+}
+
+void WinThreader::WinEvent::Wait()
+{
+	WaitForSingleObject(m_event, INFINITE);
+}
+
+void WinThreader::WinEvent::Signal()
+{
+	SetEvent(m_event);
+}
+
+void WinThreader::WinEvent::DestroyThis()
+{
+	delete this;
+}
+
diff --git a/dlls/sqlite/thread/WinThreads.h b/dlls/sqlite/thread/WinThreads.h
new file mode 100644
index 00000000..4bec6fd3
--- /dev/null
+++ b/dlls/sqlite/thread/WinThreads.h
@@ -0,0 +1,82 @@
+#ifndef _INCLUDE_WINTHREADS_H_
+#define _INCLUDE_WINTHREADS_H_
+
+#include <windows.h>
+#include "IThreader.h"
+
+using namespace SourceMod;
+
+DWORD WINAPI Win32_ThreadGate(LPVOID param);
+
+class WinThreader : public IThreader
+{
+public:
+	class ThreadHandle : public IThreadHandle
+	{
+		friend class WinThreader;
+		friend DWORD WINAPI Win32_ThreadGate(LPVOID param);
+	public:
+		ThreadHandle(IThreader *parent, HANDLE hthread, IThread *run, const ThreadParams *params);
+		virtual ~ThreadHandle();
+	public:
+		virtual bool WaitForThread();
+		virtual void DestroyThis();
+		virtual IThreadCreator *Parent();
+		virtual void GetParams(ThreadParams *ptparams);
+		virtual ThreadPriority GetPriority();
+		virtual bool SetPriority(ThreadPriority prio);
+		virtual ThreadState GetState();
+		virtual bool Unpause();
+	protected:
+		IThreader *m_parent;		//Parent handle
+		HANDLE m_thread;			//Windows HANDLE	
+		ThreadParams m_params;		//Current Parameters
+		IThread *m_run;	//Runnable context
+		ThreadState m_state;		//internal state
+		CRITICAL_SECTION m_crit;
+	};
+	class WinMutex : public IMutex
+	{
+	public:
+		WinMutex(HANDLE mutex) : m_mutex(mutex)
+		{
+		};
+		virtual ~WinMutex();
+	public:
+		virtual bool TryLock();
+		virtual void Lock();
+		virtual void Unlock();
+		virtual void DestroyThis();
+	protected:
+		HANDLE m_mutex;
+	};
+	class WinEvent : public IEventSignal
+	{
+	public:
+		WinEvent(HANDLE event) : m_event(event)
+		{
+		};
+		virtual ~WinEvent();
+	public:
+		virtual void Wait();
+		virtual void Signal();
+		virtual void DestroyThis();
+	public:
+		HANDLE m_event;
+	};
+public:
+	virtual IMutex *MakeMutex();
+	virtual void MakeThread(IThread *pThread);
+	virtual IThreadHandle *MakeThread(IThread *pThread, ThreadFlags flags);
+	virtual IThreadHandle *MakeThread(IThread *pThread, const ThreadParams *params);
+	virtual void GetPriorityBounds(ThreadPriority &max, ThreadPriority &min);
+	virtual void ThreadSleep(unsigned int ms);
+	virtual IEventSignal *MakeEventSignal();
+};
+
+#if defined SM_DEFAULT_THREADER && !defined SM_MAIN_THREADER
+#define SM_MAIN_THREADER WinThreader;
+typedef class WinThreader MainThreader;
+#endif
+
+#endif //_INCLUDE_WINTHREADS_H_
diff --git a/dlls/sqlite/threading.cpp b/dlls/sqlite/threading.cpp
new file mode 100644
index 00000000..052af444
--- /dev/null
+++ b/dlls/sqlite/threading.cpp
@@ -0,0 +1,661 @@
+#include "amxxmodule.h"
+#include "sqlite_header.h"
+#include "threading.h"
+
+using namespace SourceMod;
+using namespace SourceHook;
+
+MainThreader g_Threader;
+ThreadWorker *g_pWorker = NULL;
+extern DLL_FUNCTIONS *g_pFunctionTable;
+StringPool g_StringPool;
+IMutex *g_QueueLock = NULL;
+CStack<MysqlThread *> g_ThreadQueue;
+CStack<MysqlThread *> g_FreeThreads;
+float g_lasttime = 0.0f;
+
+void ShutdownThreading()
+{
+	if (g_pWorker)
+	{
+		g_pWorker->Stop(true);
+		delete g_pWorker;
+		g_pWorker = NULL;
+	}
+
+	g_QueueLock->Lock();
+	while (!g_ThreadQueue.empty())
+	{
+		delete g_ThreadQueue.front();
+		g_ThreadQueue.pop();
+	}
+	while (!g_FreeThreads.empty())
+	{
+		delete g_FreeThreads.front();
+		g_FreeThreads.pop();
+	}
+	g_QueueLock->Unlock();
+	g_QueueLock->DestroyThis();
+
+	FreeHandleTable();
+}
+
+//public QueryHandler(state, Handle:query, error[], errnum, data[], size)
+//native SQL_ThreadQuery(Handle:cn_tuple, const handler[], const query[], const data[]="", dataSize=0);
+static cell AMX_NATIVE_CALL SQL_ThreadQuery(AMX *amx, cell *params)
+{
+	if (!g_pWorker)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Thread worker was unable to start.");
+		return 0;
+	}
+
+	SQL_Connection *cn = (SQL_Connection *)GetHandle(params[1], Handle_Connection);
+	if (!cn)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Invalid handle: %d", params[1]);
+		return 0;
+	}
+
+	int len;
+	const char *handler = MF_GetAmxString(amx, params[2], 0, &len);
+	int fwd = MF_RegisterSPForwardByName(amx, handler, FP_CELL, FP_CELL, FP_STRING, FP_CELL, FP_ARRAY, FP_CELL, FP_DONE);
+	if (fwd < 1)
+	{
+		MF_LogError(amx, AMX_ERR_NATIVE, "Function not found: %s", handler);
+		return 0;
+	}
+
+	MysqlThread *kmThread;
+	g_QueueLock->Lock();
+	if (g_FreeThreads.empty())
+	{
+		kmThread = new MysqlThread();
+	} else {
+		kmThread = g_FreeThreads.front();
+		g_FreeThreads.pop();
+	}
+	g_QueueLock->Unlock();
+
+	kmThread->SetInfo(cn->db);
+	kmThread->SetForward(fwd);
+	kmThread->SetQuery(MF_GetAmxString(amx, params[3], 1, &len));
+	kmThread->SetCellData(MF_GetAmxAddr(amx, params[4]), (ucell)params[5]);
+
+	g_pWorker->MakeThread(kmThread);
+
+	return 1;
+}
+
+MysqlThread::MysqlThread()
+{
+	m_fwd = 0;
+	m_data = NULL;
+	m_datalen = 0;
+	m_maxdatalen = 0;
+}
+
+MysqlThread::~MysqlThread()
+{
+	if (m_fwd)
+	{
+		MF_UnregisterSPForward(m_fwd);
+		m_fwd = 0;
+	}
+	
+	delete [] m_data;
+	m_data = NULL;
+}
+
+void MysqlThread::SetCellData(cell data[], ucell len)
+{
+	if (len > m_maxdatalen)
+	{
+		delete [] m_data;
+		m_data = new cell[len];
+		m_maxdatalen = len;
+	}
+	if (len)
+	{
+		m_datalen = len;
+		memcpy(m_data, data, len*sizeof(cell));
+	}
+}
+
+void MysqlThread::SetForward(int forward)
+{
+	m_fwd = forward;
+}
+
+void MysqlThread::SetInfo(const char *db)
+{
+	m_db.assign(db);
+}
+
+void MysqlThread::SetQuery(const char *query)
+{
+	m_query.assign(query);
+}
+
+void MysqlThread::RunThread(IThreadHandle *pHandle)
+{
+	DatabaseInfo info;
+
+	info.database = m_db.c_str();
+	info.pass = "";
+	info.user = "";
+	info.host = "";
+	info.port = 0;
+
+	memset(&m_qrInfo, 0, sizeof(m_qrInfo));
+
+	IDatabase *pDatabase = g_Sqlite.Connect(&info, &m_qrInfo.amxinfo.info.errorcode, m_qrInfo.amxinfo.error, 254);
+	IQuery *pQuery = NULL;
+	if (!pDatabase)
+	{
+		m_qrInfo.connect_success = false;
+		m_qrInfo.query_success = false;
+	} else {
+		m_qrInfo.connect_success = true;
+		pQuery = pDatabase->PrepareQuery(m_query.c_str());
+		if (!pQuery->Execute(&m_qrInfo.amxinfo.info, m_qrInfo.amxinfo.error, 254))
+		{
+			m_qrInfo.query_success = false;
+		} else {
+			m_qrInfo.query_success = true;
+		}
+	}
+
+	if (m_qrInfo.query_success && m_qrInfo.amxinfo.info.rs)
+	{
+		m_atomicResult.CopyFrom(m_qrInfo.amxinfo.info.rs);
+		m_qrInfo.amxinfo.pQuery = NULL;
+		m_qrInfo.amxinfo.info.rs = &m_atomicResult;
+	}
+
+	if (pQuery)
+	{
+		pQuery->FreeHandle();
+		pQuery = NULL;
+	}
+	if (pDatabase)
+	{
+		pDatabase->FreeHandle();
+		pDatabase = NULL;
+	}
+}
+
+void MysqlThread::Invalidate()
+{
+	m_atomicResult.FreeHandle();
+}
+
+void MysqlThread::OnTerminate(IThreadHandle *pHandle, bool cancel)
+{
+	if (cancel)
+	{
+		Invalidate();
+		g_QueueLock->Lock();
+		g_FreeThreads.push(this);
+		g_QueueLock->Unlock();
+	} else {
+		g_QueueLock->Lock();
+		g_ThreadQueue.push(this);
+		g_QueueLock->Unlock();
+	}
+}
+
+void NullFunc(void *ptr, unsigned int num)
+{
+}
+
+//public QueryHandler(state, Handle:query, error[], errnum, data[], size)
+void MysqlThread::Execute()
+{
+	cell data_addr;
+	if (m_datalen)
+	{
+		data_addr = MF_PrepareCellArray(m_data, m_datalen);
+	} else {
+		static cell tmpdata[1] = {0};
+		data_addr = MF_PrepareCellArray(tmpdata, 1);
+	}
+	int state = 0;
+	if (!m_qrInfo.connect_success)
+	{
+		state = -2;
+	} else if (!m_qrInfo.query_success) {
+		state = -1;
+	}
+	if (state != 0)
+	{
+		MF_ExecuteForward(m_fwd, 
+			(cell)state, 
+			(cell)0, 
+			m_qrInfo.amxinfo.error, 
+			m_qrInfo.amxinfo.info.errorcode,
+			data_addr,
+			m_datalen);
+	} else {
+		unsigned int hndl = MakeHandle(&m_qrInfo.amxinfo, Handle_Query, NullFunc);
+		MF_ExecuteForward(m_fwd,
+			(cell)0,
+			(cell)hndl,
+			"",
+			(cell)0,
+			data_addr,
+			m_datalen);
+		FreeHandle(hndl);
+	}
+}
+
+/*****************
+ * METAMOD STUFF *
+ *****************/
+
+void OnPluginsLoaded()
+{
+	if (g_pWorker)
+	{
+		return;
+	}
+
+	if (!g_StringPool.IsThreadable())
+	{
+		g_StringPool.SetMutex(g_Threader.MakeMutex());
+		g_QueueLock = g_Threader.MakeMutex();
+	}
+	g_pWorker = new ThreadWorker(&g_Threader, 250);
+	if (!g_pWorker->Start())
+	{
+		delete g_pWorker;
+		g_pWorker = NULL;
+	}
+	g_pFunctionTable->pfnSpawn = NULL;
+
+	g_lasttime = 0.0f;
+
+	return;
+}
+
+void StartFrame()
+{
+	if (g_pWorker && (g_lasttime < gpGlobals->time))
+	{
+        g_lasttime = gpGlobals->time + 0.3f;
+		g_QueueLock->Lock();
+		size_t remaining = g_ThreadQueue.size();
+		if (remaining)
+		{
+			MysqlThread *kmThread;
+			do 
+			{
+				kmThread = g_ThreadQueue.front();
+				g_ThreadQueue.pop();
+				g_QueueLock->Unlock();
+				kmThread->Execute();
+				kmThread->Invalidate();
+				g_FreeThreads.push(kmThread);
+				g_QueueLock->Lock();
+			} while (!g_ThreadQueue.empty());
+		}
+
+		g_QueueLock->Unlock();
+	}
+
+	RETURN_META(MRES_IGNORED);
+}
+
+void OnPluginsUnloading()
+{
+	if (!g_pWorker)
+		return;
+
+	g_pWorker->Stop(false);
+	delete g_pWorker;
+	g_pWorker = NULL;
+}
+
+/***********************
+ * ATOMIC RESULT STUFF *
+ ***********************/
+
+AtomicResult::AtomicResult()
+{
+	m_IsFree = true;
+	m_CurRow = 0;
+	m_AllocFields = 0;
+	m_AllocRows = 0;
+	m_Rows = NULL;
+	m_Fields = NULL;
+}
+
+AtomicResult::~AtomicResult()
+{
+	if (!m_IsFree)
+	{
+		FreeHandle();
+	}
+
+	if (m_AllocFields)
+	{
+		delete [] m_Fields;
+		m_AllocFields = 0;
+		m_Fields = NULL;
+	}
+	if (m_AllocRows)
+	{
+		for (unsigned int i=0; i<m_AllocRows; i++)
+			delete [] m_Rows[i];
+		delete [] m_Rows;
+		m_AllocRows = 0;
+		m_Rows = NULL;
+	}
+}
+
+unsigned int AtomicResult::RowCount()
+{
+	return m_RowCount;
+}
+
+bool AtomicResult::IsNull(unsigned int columnId)
+{
+	return (GetString(columnId) == NULL);
+}
+
+unsigned int AtomicResult::FieldCount()
+{
+	return m_FieldCount;
+}
+
+bool AtomicResult::FieldNameToNum(const char *name, unsigned int *columnId)
+{
+	for (unsigned int i=0; i<m_FieldCount; i++)
+	{
+		if (strcmp(g_StringPool.GetString(m_Fields[i]), name) == 0)
+		{
+			if (*columnId)
+				*columnId = i;
+			return true;
+		}
+	}
+
+	return false;
+}
+
+const char *AtomicResult::FieldNumToName(unsigned int num)
+{
+	if (num >= m_FieldCount)
+		return NULL;
+
+	return g_StringPool.GetString(m_Fields[num]);
+}
+
+double AtomicResult::GetDouble(unsigned int columnId)
+{
+	return atof(GetStringSafe(columnId));
+}
+
+float AtomicResult::GetFloat(unsigned int columnId)
+{
+	return atof(GetStringSafe(columnId));
+}
+
+int AtomicResult::GetInt(unsigned int columnId)
+{
+	return atoi(GetStringSafe(columnId));
+}
+
+const char *AtomicResult::GetRaw(unsigned int columnId, size_t *length)
+{
+	//we don't support this yet...
+	*length = 0;
+	return "";
+}
+
+const char *AtomicResult::GetStringSafe(unsigned int columnId)
+{
+	const char *str = GetString(columnId);
+	
+	return str ? str : "";
+}
+
+const char *AtomicResult::GetString(unsigned int columnId)
+{
+	if (columnId >= m_FieldCount)
+		return NULL;
+
+	return g_StringPool.GetString(m_Rows[m_CurRow][columnId]);
+}
+
+IResultRow *AtomicResult::GetRow()
+{
+	return static_cast<IResultRow *>(this);
+}
+
+bool AtomicResult::IsDone()
+{
+	if (m_CurRow >= m_RowCount)
+		return true;
+
+	return false;
+}
+
+void AtomicResult::NextRow()
+{
+	m_CurRow++;
+}
+
+void AtomicResult::_InternalClear()
+{
+	if (m_IsFree)
+		return;
+
+	m_IsFree = true;
+
+	g_StringPool.StartHardLock();
+
+	for (unsigned int i=0; i<m_FieldCount; i++)
+		g_StringPool.FreeString(m_Fields[i]);
+
+	for (unsigned int i=0; i<m_RowCount; i++)
+	{
+		for (unsigned int j=0; j<m_FieldCount; j++)
+			g_StringPool.FreeString(m_Rows[i][j]);
+	}
+
+	g_StringPool.StopHardLock();
+}
+
+void AtomicResult::FreeHandle()
+{
+	_InternalClear();
+}
+
+void AtomicResult::CopyFrom(IResultSet *rs)
+{
+	if (!m_IsFree)
+	{
+		_InternalClear();
+	}
+
+	m_IsFree = false;
+
+	m_FieldCount = rs->FieldCount();
+	m_RowCount = rs->RowCount();
+	if (m_RowCount > m_AllocRows)
+	{
+		/** allocate new array, zero it */
+		stridx_t **newRows = new stridx_t *[m_RowCount];
+		memset(newRows, 0, m_RowCount * sizeof(stridx_t *));
+		/** if we have a new field count, just delete all the old stuff. */
+		if (m_FieldCount > m_AllocFields)
+		{
+			for (unsigned int i=0; i<m_AllocRows; i++)
+			{
+				delete [] m_Rows[i];
+				newRows[i] = new stridx_t[m_FieldCount];
+			}
+			for (unsigned int i=m_AllocRows; i<m_RowCount; i++)
+				newRows[i] = new stridx_t[m_FieldCount];
+		} else {
+			/** copy the old pointers */
+			memcpy(newRows, m_Rows, m_AllocRows * sizeof(stridx_t *));
+			for (unsigned int i=m_AllocRows; i<m_RowCount; i++)
+				newRows[i] = new stridx_t[m_AllocFields];
+		}
+		delete [] m_Rows;
+		m_Rows = newRows;
+		m_AllocRows = m_RowCount;
+	}
+	if (m_FieldCount > m_AllocFields)
+	{
+		delete [] m_Fields;
+		m_Fields = new stridx_t[m_FieldCount];
+		m_AllocFields = m_FieldCount;
+	}
+	m_CurRow = 0;
+
+	g_StringPool.StartHardLock();
+
+	IResultRow *row;
+	unsigned int idx = 0;
+	while (!rs->IsDone())
+	{
+		row = rs->GetRow();
+		for (size_t i=0; i<m_FieldCount; i++)
+			m_Rows[idx][i] = g_StringPool.MakeString(row->GetString(i));
+		rs->NextRow();
+		idx++;
+	}
+
+	for (unsigned int i=0; i<m_FieldCount; i++)
+		m_Fields[i] = g_StringPool.MakeString(rs->FieldNumToName(i));
+
+	g_StringPool.StopHardLock();
+}
+
+/*********************
+ * STRING POOL STUFF *
+ *********************/
+
+StringPool::StringPool()
+{
+	m_mutex = NULL;
+	m_stoplock = false;
+}
+
+StringPool::~StringPool()
+{
+	if (m_stoplock)
+		StopHardLock();
+
+	if (m_mutex)
+		UnsetMutex();
+
+	for (size_t i=0; i<m_Strings.size(); i++)
+		delete m_Strings[i];
+
+	m_Strings.clear();
+	m_UseTable.clear();
+	while (!m_FreeStrings.empty())
+		m_FreeStrings.pop();
+}
+
+bool StringPool::IsThreadable()
+{
+	return (m_mutex != NULL);
+}
+
+const char *StringPool::GetString(stridx_t idx)
+{
+	if (idx < 0 || idx >= (int)m_Strings.size() || !m_UseTable[idx])
+		return NULL;
+
+	return m_Strings[idx]->c_str();
+}
+
+void StringPool::FreeString(stridx_t idx)
+{
+	if (idx < 0 || idx >= (int)m_Strings.size())
+		return;
+
+	if (!m_stoplock && m_mutex)
+		m_mutex->Lock();
+
+	if (m_UseTable[idx])
+	{
+		m_FreeStrings.push(idx);
+		m_UseTable[idx] = 0;
+	}
+
+	if (!m_stoplock && m_mutex)
+		m_mutex->Unlock();
+}
+
+stridx_t StringPool::MakeString(const char *str)
+{
+	if (!str)
+		return StringPool::NullString;
+
+	if (!m_stoplock && m_mutex)
+		m_mutex->Lock();
+
+	stridx_t idx;
+
+	if (m_FreeStrings.empty())
+	{
+		idx = static_cast<stridx_t>(m_Strings.size());
+		SourceHook::String *shString = new SourceHook::String(str);
+		m_Strings.push_back(shString);
+		m_UseTable.push_back(1);
+	} else {
+		idx = m_FreeStrings.front();
+		m_FreeStrings.pop();
+		m_UseTable[idx] = 1;
+		m_Strings[idx]->assign(str);
+	}
+
+	if (!m_stoplock && m_mutex)
+		m_mutex->Unlock();
+
+	return idx;
+}
+
+void StringPool::SetMutex(IMutex *m)
+{
+	m_mutex = m;
+}
+
+void StringPool::UnsetMutex()
+{
+	if (m_mutex)
+	{
+		m_mutex->DestroyThis();
+		m_mutex = NULL;
+	}
+}
+
+void StringPool::StartHardLock()
+{
+	if (m_stoplock)
+		return;
+
+	m_mutex->Lock();
+	m_stoplock = true;
+}
+
+void StringPool::StopHardLock()
+{
+	if (!m_stoplock)
+		return;
+
+	m_mutex->Unlock();
+	m_stoplock = false;
+}
+
+AMX_NATIVE_INFO g_ThreadSqlNatives[] =
+{
+	{"SQL_ThreadQuery",			SQL_ThreadQuery},
+	{NULL,						NULL},
+};
diff --git a/dlls/sqlite/threading.h b/dlls/sqlite/threading.h
new file mode 100644
index 00000000..92147176
--- /dev/null
+++ b/dlls/sqlite/threading.h
@@ -0,0 +1,110 @@
+#ifndef _INCLUDE_MYSQL_THREADING_H
+#define _INCLUDE_MYSQL_THREADING_H
+
+#include "IThreader.h"
+#include "ISQLDriver.h"
+#include "sh_string.h"
+#include "CVector.h"
+#include "sh_stack.h"
+
+struct QueuedResultInfo
+{
+	AmxQueryInfo amxinfo;
+	bool connect_success;
+	bool query_success;
+};
+
+typedef int stridx_t;
+
+class StringPool
+{
+public:
+	StringPool();
+	~StringPool();
+	void SetMutex(IMutex *m);
+	void UnsetMutex();
+	bool IsThreadable();
+public:
+	stridx_t MakeString(const char *str);
+	void FreeString(stridx_t idx);
+	const char *GetString(stridx_t idx);
+	void StartHardLock();
+	void StopHardLock();
+public:
+	static const int NullString = -1;
+private:
+	CStack<stridx_t> m_FreeStrings;
+	CVector<stridx_t> m_UseTable;
+	CVector<SourceHook::String *> m_Strings;
+	IMutex *m_mutex;
+	bool m_stoplock;
+};
+
+class AtomicResult : 
+	public IResultSet,
+	public IResultRow
+{
+	friend class MysqlThread;
+public:
+	AtomicResult();
+	~AtomicResult();
+public:
+	//free the handle if necessary (see IQuery).
+	virtual void FreeHandle();
+	virtual unsigned int RowCount();
+	virtual unsigned int FieldCount();
+	virtual const char *FieldNumToName(unsigned int num);
+	virtual bool FieldNameToNum(const char *name, unsigned int *columnId);
+	virtual bool IsDone();
+	virtual IResultRow *GetRow();
+	virtual void NextRow();
+public:
+	virtual const char *GetString(unsigned int columnId);
+	virtual const char *GetStringSafe(unsigned int columnId);
+	virtual double GetDouble(unsigned int columnId);
+	virtual float GetFloat(unsigned int columnId);
+	virtual int GetInt(unsigned int columnId);
+	virtual bool IsNull(unsigned int columnId);
+	virtual const char *GetRaw(unsigned int columnId, size_t *length);
+public:
+	void CopyFrom(IResultSet *rs);
+private:
+	void _InternalClear();
+private:
+	unsigned int m_RowCount;
+	unsigned int m_FieldCount;
+	unsigned int m_AllocFields;
+	unsigned int m_AllocRows;
+	stridx_t *m_Fields;
+	stridx_t **m_Rows;
+	unsigned int m_CurRow;
+	bool m_IsFree;
+};
+
+class MysqlThread : public IThread
+{
+public:
+	MysqlThread();
+	~MysqlThread();
+public:
+	void SetInfo(const char *db);
+	void SetQuery(const char *query);
+	void SetCellData(cell data[], ucell len);
+	void SetForward(int forward);
+	void Invalidate();
+	void Execute();
+public:
+	void RunThread(IThreadHandle *pHandle);
+	void OnTerminate(IThreadHandle *pHandle, bool cancel);
+private:
+	SourceHook::String m_query;
+	SourceHook::String m_db;
+	cell *m_data;
+	ucell m_datalen;
+	size_t m_maxdatalen;
+	int m_fwd;
+	QueuedResultInfo m_qrInfo;
+	AtomicResult m_atomicResult;
+};
+
+#endif //_INCLUDE_MYSQL_THREADING_H