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

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

diff --git a/dlls/regex/CRegEx.cpp b/dlls/regex/CRegEx.cpp
new file mode 100755
index 00000000..7dacb81f
--- /dev/null
+++ b/dlls/regex/CRegEx.cpp
@@ -0,0 +1,112 @@
+#include "pcre.h"
+#include "CRegEx.h"
+#include <string.h>
+
+RegEx::RegEx()
+{
+	mErrorOffset = 0;
+	mError = NULL;
+	re = NULL;
+	mFree = true;
+	subject = NULL;
+	mSubStrings = 0;
+}
+
+void RegEx::Clear()
+{
+	mErrorOffset = 0;
+	mError = NULL;
+	if (re)
+		pcre_free(re);
+	re = NULL;
+	mFree = true;
+	if (subject)
+		delete [] subject;
+	subject = NULL;
+	mSubStrings = 0;
+}
+
+RegEx::~RegEx()
+{
+	Clear();
+}
+
+bool RegEx::isFree(bool set, bool val)
+{
+	if (set)
+	{
+		mFree = val;
+		return true;
+	} else {
+		return mFree;
+	}
+}
+
+int RegEx::Compile(const char *pattern)
+{
+	int errno;
+
+	if (!mFree)
+		Clear();
+
+	re = pcre_compile(pattern, 0, &mError, &mErrorOffset, NULL);
+
+	if (re == NULL)
+	{
+		return 0;
+	}
+
+	mFree = false;
+
+	return 1;
+}
+
+int RegEx::Match(const char *str)
+{
+	int rc = 0;
+
+	if (mFree || re == NULL)
+		return -1;
+
+	//save str
+	subject = new char[strlen(str)+1];
+	strcpy(subject, str);
+
+	rc = pcre_exec(re, NULL, subject, (int)strlen(subject), 0, 0, ovector, 30);
+
+	if (rc < 0)
+	{
+		if (rc == PCRE_ERROR_NOMATCH)
+		{
+			return 0;
+		} else {
+			mErrorOffset = rc;
+			return -1;
+		}
+	}
+
+	mSubStrings = rc;
+
+	return 1;
+}
+
+const char *RegEx::GetSubstring(int s, char buffer[], int max)
+{
+	if (s >= mSubStrings || s < 0)
+		return NULL;
+
+	char *substr_a = subject + ovector[2*s];
+	int substr_l = ovector[2*s+1] - ovector[2*s];
+
+	for (int i = 0; i<substr_l; i++)
+	{
+		if (i >= max)
+			break;
+		buffer[i] = substr_a[i];
+	}
+
+	buffer[i] = '\0';
+
+	return buffer;
+}
+
diff --git a/dlls/regex/CRegEx.h b/dlls/regex/CRegEx.h
new file mode 100755
index 00000000..6a7d023b
--- /dev/null
+++ b/dlls/regex/CRegEx.h
@@ -0,0 +1,26 @@
+#ifndef _INCLUDE_CREGEX_H
+#define _INCLUDE_CREGEX_H
+
+class RegEx
+{
+public:
+	RegEx();
+	~RegEx();
+	bool isFree(bool set=false, bool val=false);
+	void Clear();
+
+	int Compile(const char *pattern);
+	int Match(const char *str);
+	const char *GetSubstring(int s, char buffer[], int max);
+public:
+	int mErrorOffset;
+	const char *mError;
+	int mSubStrings;
+private:
+	pcre *re;
+	bool mFree;
+	int ovector[30];
+	char *subject;
+};
+
+#endif //_INCLUDE_CREGEX_H
\ No newline at end of file
diff --git a/dlls/regex/CVector.h b/dlls/regex/CVector.h
new file mode 100755
index 00000000..05538f53
--- /dev/null
+++ b/dlls/regex/CVector.h
@@ -0,0 +1,444 @@
+/* AMX Mod X
+*
+* by the AMX Mod X Development Team
+*  originally developed by OLO
+*
+*
+*  This program is free software; you can redistribute it and/or modify it
+*  under the terms of the GNU General Public License as published by the
+*  Free Software Foundation; either version 2 of the License, or (at
+*  your option) any later version.
+*
+*  This program is distributed in the hope that it will be useful, but
+*  WITHOUT ANY WARRANTY; without even the implied warranty of
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+*  General Public License for more details.
+*
+*  You should have received a copy of the GNU General Public License
+*  along with this program; if not, write to the Free Software Foundation,
+*  Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*
+*  In addition, as a special exception, the author gives permission to
+*  link the code of this program with the Half-Life Game Engine ("HL
+*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
+*  L.L.C ("Valve"). You must obey the GNU General Public License in all
+*  respects for all of the code used other than the HL Engine and MODs
+*  from Valve. If you modify this file, you may extend this exception
+*  to your version of the file, but you are not obligated to do so. If
+*  you do not wish to do so, delete this exception statement from your
+*  version.
+*/
+
+#ifndef __CVECTOR_H__
+#define __CVECTOR_H__
+
+#include <assert.h>
+
+// Vector
+template <class T> class CVector
+{
+	bool Grow()
+	{
+		// automatic grow
+		size_t newSize = m_Size * 2;
+		if (newSize == 0)
+			newSize = 8;					// a good init value
+		T *newData = new T[newSize];
+		if (!newData)
+			return false;
+		if (m_Data)
+		{
+			memcpy(newData, m_Data, m_Size * sizeof(T));
+			delete [] m_Data;
+		}
+		m_Data = newData;
+		m_Size = newSize;
+		return true;
+	}
+
+	bool GrowIfNeeded()
+	{
+		if (m_CurrentUsedSize >= m_Size)
+			return Grow();
+		else
+			return true;
+	}
+
+	bool ChangeSize(size_t size)
+	{
+		// change size
+		if (size == m_Size)
+			return true;
+		T *newData = new T[size];
+		if (!newData)
+			return false;
+		if (m_Data)
+		{
+			memcpy(newData, m_Data, (m_Size < size) ? (m_Size * sizeof(T)) : (size * sizeof(T)));
+			delete [] m_Data;
+		}
+		if (m_Size < size)
+			m_CurrentSize = size;
+		m_Data = newData;
+		m_Size = size;
+		return true;
+	}
+
+	void FreeMemIfPossible()
+	{
+
+	}
+protected:
+	T *m_Data;
+	size_t m_Size;
+	size_t m_CurrentUsedSize;
+	size_t m_CurrentSize;
+public:
+	class iterator
+	{
+	protected:
+		T *m_Ptr;
+	public:
+		// constructors / destructors
+		iterator()
+		{
+			m_Ptr = NULL;
+		}
+
+		iterator(T * ptr)
+		{
+			m_Ptr = ptr;
+		}
+
+		// member functions
+		T * base()
+		{
+			return m_Ptr;
+		}
+
+		const T * base() const
+		{
+			return m_Ptr;
+		}
+
+		// operators
+		T & operator*()
+		{
+			return *m_Ptr;
+		}
+
+		T * operator->()
+		{
+			return m_Ptr;
+		}
+
+		iterator & operator++()		// preincrement
+		{
+			++m_Ptr;
+			return (*this);
+		}
+
+		iterator operator++(int)	// postincrement
+		{
+			iterator tmp = *this;
+			++m_Ptr;
+			return tmp;
+		}
+
+		iterator & operator--()		// predecrement
+		{
+			--m_Ptr;
+			return (*this);
+		}
+
+		iterator operator--(int)	// postdecrememnt
+		{
+			iterator tmp = *this;
+			--m_Ptr;
+			return tmp;
+		}
+
+		bool operator==(T * right) const
+		{
+			return (m_Ptr == right);
+		}
+
+		bool operator==(const iterator & right) const
+		{
+			return (m_Ptr == right.m_Ptr);
+		}
+
+		bool operator!=(T * right) const
+		{
+			return (m_Ptr != right);
+		}
+
+		bool operator!=(const iterator & right) const
+		{
+			return (m_Ptr != right.m_Ptr);
+		}
+
+		iterator & operator+=(size_t offset)
+		{
+			m_Ptr += offset;
+			return (*this);
+		}
+
+		iterator & operator-=(size_t offset)
+		{
+			m_Ptr += offset;
+			return (*this);
+		}
+
+		iterator operator+(size_t offset) const
+		{
+			iterator tmp(*this);
+			tmp.m_Ptr += offset;
+			return tmp;
+		}
+
+		iterator operator-(size_t offset) const
+		{
+			iterator tmp(*this);
+			tmp.m_Ptr += offset;
+			return tmp;
+		}
+		
+		T & operator[](size_t offset)
+		{
+			return (*(*this + offset));
+		}
+
+		const T & operator[](size_t offset) const
+		{
+			return (*(*this + offset));
+		}
+
+		bool operator<(const iterator & right) const
+		{
+			return m_Ptr < right.m_Ptr;
+		}
+
+		bool operator>(const iterator & right) const
+		{
+			return m_Ptr > right.m_Ptr;
+		}
+
+		bool operator<=(const iterator & right) const
+		{
+			return m_Ptr <= right.m_Ptr;
+		}
+
+		bool operator>=(const iterator & right) const
+		{
+			return m_Ptr >= right.m_Ptr;
+		}
+
+		size_t operator-(const iterator & right) const
+		{
+			return m_Ptr - right.m_Ptr;
+		}
+	};
+
+	// constructors / destructors
+	CVector<T>()
+	{
+		m_Size = 0;
+		m_CurrentUsedSize = 0;
+		m_Data = NULL;
+	}
+
+	CVector<T>(const CVector<T> & other)
+	{
+		// copy data
+		m_Data = new T [other.m_Size];
+		m_Size = other.m_Size;
+		m_CurrentUsedSize = other.m_CurrentUsedSize;
+		memcpy(m_Data, other.m_Data, m_CurrentUsedSize * sizeof(T));
+	}
+
+	~CVector<T>()
+	{
+		clear();
+	}
+
+	// interface
+	size_t size() const
+	{
+		return m_CurrentUsedSize;
+	}
+
+	size_t capacity() const
+	{
+		return m_Size;
+	}
+
+	iterator begin()
+	{
+		return iterator(m_Data);
+	}
+
+	iterator end()
+	{
+		return iterator(m_Data + m_CurrentUsedSize);
+	}
+
+	iterator iterAt(size_t pos)
+	{
+		if (pos > m_CurrentUsedSize)
+			assert(0);
+		return iterator(m_Data + pos);
+	}
+
+	bool reserve(size_t newSize)
+	{
+		return ChangeSize(newSize);
+	}
+
+	bool push_back(const T & elem)
+	{
+		++m_CurrentUsedSize;
+		if (!GrowIfNeeded())
+		{
+			--m_CurrentUsedSize;
+			return false;
+		}
+
+		m_Data[m_CurrentUsedSize - 1] = elem;
+		return true;
+	}
+
+	void pop_back()
+	{
+		--m_CurrentUsedSize;
+		if (m_CurrentUsedSize < 0)
+			m_CurrentUsedSize = 0;
+		// :TODO: free memory sometimes
+	}
+
+	bool resize(size_t newSize)
+	{
+		if (!ChangeSize(newSize))
+			return false;
+		FreeMemIfPossible();
+		return true;
+	}
+
+	bool empty() const
+	{
+		return (m_CurrentUsedSize == 0);
+	}
+
+	T & at(size_t pos)
+	{
+		if (pos > m_CurrentUsedSize)
+		{
+			assert(0);
+		}
+		return m_Data[pos];
+	}
+
+	const  T & at(size_t pos) const
+	{
+		if (pos > m_CurrentUsedSize)
+		{
+			assert(0);
+		}
+		return m_Data[pos];
+	}
+
+	T & operator[](size_t pos)
+	{
+		return at(pos);
+	}
+
+	const T & operator[](size_t pos) const
+	{
+		return at(pos);
+	}
+
+	T & front()
+	{
+		if (m_CurrentUsedSize < 1)
+		{
+			assert(0);
+		}
+		return m_Data[0];
+	}
+
+	const T & front() const
+	{
+		if (m_CurrentUsedSize < 1)
+		{
+			assert(0);
+		}
+		return m_Data[0];
+	}
+
+	T & back()
+	{
+		if (m_CurrentUsedSize < 1)
+		{
+			assert(0);
+		}
+		return m_Data[m_CurrentUsedSize - 1];
+	}
+
+	const T & back() const
+	{
+		if (m_CurrentUsedSize < 1)
+		{
+			assert(0);
+		}
+		return m_Data[m_CurrentUsedSize - 1];
+	}
+
+	bool insert(iterator where, const T & value)
+	{
+		// we have to insert before
+		// if it is begin, don't decrement
+		if (where != m_Data)
+			--where;
+		// validate iter
+		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
+			return false;
+
+		++m_CurrentUsedSize;
+		if (!GrowIfNeeded())
+		{
+			--m_CurrentUsedSize;
+			return false;
+		}
+
+		memmove(where.base() + 1, where.base(), m_CurrentUsedSize - (where - m_Data));
+		memcpy(where.base(), &value, sizeof(T));
+		return true;
+	}
+
+	void erase(iterator where)
+	{
+		// validate iter
+		if (where < m_Data || where >= (m_Data + m_CurrentUsedSize))
+			return false;
+
+		if (m_CurrentUsedSize > 1)
+		{
+			// move
+			memmove(where.base(), where.base() + 1, m_CurrentUsedSize - 1);
+		}
+
+		--m_CurrentUsedSize;
+		// :TODO: free memory sometimes
+	}
+
+	void clear()
+	{
+		m_Size = 0;
+		m_CurrentUsedSize = 0;
+		delete [] m_Data;
+		m_Data = NULL;
+	}
+};
+
+#endif // __CVECTOR_H__
+
diff --git a/dlls/regex/amxxmodule.cpp b/dlls/regex/amxxmodule.cpp
new file mode 100755
index 00000000..9f4e7ebb
--- /dev/null
+++ b/dlls/regex/amxxmodule.cpp
@@ -0,0 +1,3042 @@
+/* AMX Mod X
+*
+* by the AMX Mod X Development Team
+*  originally developed by OLO
+*
+* Parts Copyright (C) 2001-2003 Will Day <willday@hpgx.net>
+*
+*  This program is free software; you can redistribute it and/or modify it
+*  under the terms of the GNU General Public License as published by the
+*  Free Software Foundation; either version 2 of the License, or (at
+*  your option) any later version.
+*
+*  This program is distributed in the hope that it will be useful, but
+*  WITHOUT ANY WARRANTY; without even the implied warranty of
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+*  General Public License for more details.
+*
+*  You should have received a copy of the GNU General Public License
+*  along with this program; if not, write to the Free Software Foundation,
+*  Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*
+*  In addition, as a special exception, the author gives permission to
+*  link the code of this program with the Half-Life Game Engine ("HL
+*  Engine") and Modified Game Libraries ("MODs") developed by Valve,
+*  L.L.C ("Valve"). You must obey the GNU General Public License in all
+*  respects for all of the code used other than the HL Engine and MODs
+*  from Valve. If you modify this file, you may extend this exception
+*  to your version of the file, but you are not obligated to do so. If
+*  you do not wish to do so, delete this exception statement from your
+*  version.
+*
+*  Description: AMX Mod X Module Interface Functions
+*/
+
+#include <string.h>
+#include <new>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "amxxmodule.h"
+
+/************* METAMOD SUPPORT *************/
+#ifdef USE_METAMOD
+
+enginefuncs_t g_engfuncs;
+globalvars_t  *gpGlobals;
+
+
+
+DLL_FUNCTIONS *g_pFunctionTable;
+DLL_FUNCTIONS *g_pFunctionTable_Post;
+enginefuncs_t *g_pengfuncsTable;
+enginefuncs_t *g_pengfuncsTable_Post;
+NEW_DLL_FUNCTIONS *g_pNewFunctionsTable;
+NEW_DLL_FUNCTIONS *g_pNewFunctionsTable_Post;
+
+
+// GetEntityAPI2 functions
+static DLL_FUNCTIONS g_EntityAPI_Table = 
+{
+#ifdef FN_GameDLLInit
+	FN_GameDLLInit,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchSpawn
+	FN_DispatchSpawn,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchThink
+	FN_DispatchThink,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchUse
+	FN_DispatchUse,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchTouch
+	FN_DispatchTouch,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchBlocked
+	FN_DispatchBlocked,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchKeyValue
+	FN_DispatchKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchSave
+	FN_DispatchSave,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchRestore
+	FN_DispatchRestore,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchObjectCollsionBox
+	FN_DispatchObjectCollsionBox,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveWriteFields
+	FN_SaveWriteFields,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveReadFields
+	FN_SaveReadFields,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveGlobalState
+	FN_SaveGlobalState,
+#else
+	NULL,
+#endif
+#ifdef FN_RestoreGlobalState
+	FN_RestoreGlobalState,
+#else
+	NULL,
+#endif
+#ifdef FN_ResetGlobalState
+	FN_ResetGlobalState,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientConnect
+	FN_ClientConnect,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientDisconnect
+	FN_ClientDisconnect,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientKill
+	FN_ClientKill,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientPutInServer
+	FN_ClientPutInServer,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientCommand
+	FN_ClientCommand,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientUserInfoChanged
+	FN_ClientUserInfoChanged,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerActivate
+	FN_ServerActivate,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerDeactivate
+	FN_ServerDeactivate,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerPreThink
+	FN_PlayerPreThink,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerPostThink
+	FN_PlayerPostThink,
+#else
+	NULL,
+#endif
+#ifdef FN_StartFrame
+	FN_StartFrame,
+#else
+	NULL,
+#endif
+#ifdef FN_ParmsNewLevel
+	FN_ParmsNewLevel,
+#else
+	NULL,
+#endif
+#ifdef FN_ParmsChangeLevel
+	FN_ParmsChangeLevel,
+#else
+	NULL,
+#endif
+#ifdef FN_GetGameDescription
+	FN_GetGameDescription,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerCustomization
+	FN_PlayerCustomization,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorConnect
+	FN_SpectatorConnect,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorDisconnect
+	FN_SpectatorDisconnect,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorThink
+	FN_SpectatorThink,
+#else
+	NULL,
+#endif
+#ifdef FN_Sys_Error
+	FN_Sys_Error,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_Move
+	FN_PM_Move,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_Init
+	FN_PM_Init,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_FindTextureType
+	FN_PM_FindTextureType,
+#else
+	NULL,
+#endif
+#ifdef FN_SetupVisibility
+	FN_SetupVisibility,
+#else
+	NULL,
+#endif
+#ifdef FN_UpdateClientData
+	FN_UpdateClientData,
+#else
+	NULL,
+#endif
+#ifdef FN_AddToFullPack
+	FN_AddToFullPack,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateBaseline
+	FN_CreateBaseline,
+#else
+	NULL,
+#endif
+#ifdef FN_RegisterEncoders
+	FN_RegisterEncoders,
+#else
+	NULL,
+#endif
+#ifdef FN_GetWeaponData
+	FN_GetWeaponData,
+#else
+	NULL,
+#endif
+#ifdef FN_CmdStart
+	FN_CmdStart,
+#else
+	NULL,
+#endif
+#ifdef FN_CmdEnd
+	FN_CmdEnd,
+#else
+	NULL,
+#endif
+#ifdef FN_ConnectionlessPacket
+	FN_ConnectionlessPacket,
+#else
+	NULL,
+#endif
+#ifdef FN_GetHullBounds
+	FN_GetHullBounds,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateInstancedBaselines
+	FN_CreateInstancedBaselines,
+#else
+	NULL,
+#endif
+#ifdef FN_InconsistentFile
+	FN_InconsistentFile,
+#else
+	NULL,
+#endif
+#ifdef FN_AllowLagCompensation
+	FN_AllowLagCompensation
+#else
+	NULL
+#endif
+}; // g_EntityAPI2_Table
+
+// GetEntityAPI2_Post functions
+static DLL_FUNCTIONS g_EntityAPI_Post_Table = 
+{
+#ifdef FN_GameDLLInit_Post
+	FN_GameDLLInit_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchSpawn_Post
+	FN_DispatchSpawn_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchThink_Post
+	FN_DispatchThink_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchUse_Post
+	FN_DispatchUse_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchTouch_Post
+	FN_DispatchTouch_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchBlocked_Post
+	FN_DispatchBlocked_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchKeyValue_Post
+	FN_DispatchKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchSave_Post
+	FN_DispatchSave_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchRestore_Post
+	FN_DispatchRestore_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DispatchObjectCollsionBox_Post
+	FN_DispatchObjectCollsionBox_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveWriteFields_Post
+	FN_SaveWriteFields_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveReadFields_Post
+	FN_SaveReadFields_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveGlobalState_Post
+	FN_SaveGlobalState_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RestoreGlobalState_Post
+	FN_RestoreGlobalState_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ResetGlobalState_Post
+	FN_ResetGlobalState_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientConnect_Post
+	FN_ClientConnect_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientDisconnect_Post
+	FN_ClientDisconnect_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientKill_Post
+	FN_ClientKill_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientPutInServer_Post
+	FN_ClientPutInServer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientCommand_Post
+	FN_ClientCommand_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientUserInfoChanged_Post
+	FN_ClientUserInfoChanged_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerActivate_Post
+	FN_ServerActivate_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerDeactivate_Post
+	FN_ServerDeactivate_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerPreThink_Post
+	FN_PlayerPreThink_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerPostThink_Post
+	FN_PlayerPostThink_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_StartFrame_Post
+	FN_StartFrame_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ParmsNewLevel_Post
+	FN_ParmsNewLevel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ParmsChangeLevel_Post
+	FN_ParmsChangeLevel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetGameDescription_Post
+	FN_GetGameDescription_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PlayerCustomization_Post
+	FN_PlayerCustomization_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorConnect_Post
+	FN_SpectatorConnect_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorDisconnect_Post
+	FN_SpectatorDisconnect_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SpectatorThink_Post
+	FN_SpectatorThink_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Sys_Error_Post
+	FN_Sys_Error_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_Move_Post
+	FN_PM_Move_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_Init_Post
+	FN_PM_Init_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PM_FindTextureType_Post
+	FN_PM_FindTextureType_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetupVisibility_Post
+	FN_SetupVisibility_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_UpdateClientData_Post
+	FN_UpdateClientData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AddToFullPack_Post
+	FN_AddToFullPack_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateBaseline_Post
+	FN_CreateBaseline_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RegisterEncoders_Post
+	FN_RegisterEncoders_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetWeaponData_Post
+	FN_GetWeaponData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CmdStart_Post
+	FN_CmdStart_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CmdEnd_Post
+	FN_CmdEnd_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ConnectionlessPacket_Post
+	FN_ConnectionlessPacket_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetHullBounds_Post
+	FN_GetHullBounds_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateInstancedBaselines_Post
+	FN_CreateInstancedBaselines_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_InconsistentFile_Post
+	FN_InconsistentFile_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AllowLagCompensation
+	FN_AllowLagCompensation,
+#else
+	NULL,
+#endif
+}; // g_EntityAPI2_Table
+
+static enginefuncs_t g_EngineFuncs_Table = 
+{
+#ifdef FN_PrecacheModel
+	FN_PrecacheModel,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheSound
+	FN_PrecacheSound,
+#else
+	NULL,
+#endif
+#ifdef FN_SetModel
+	FN_SetModel,
+#else
+	NULL,
+#endif
+#ifdef FN_ModelIndex
+	FN_ModelIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_ModelFrames
+	FN_ModelFrames,
+#else
+	NULL,
+#endif
+#ifdef FN_SetSize
+	FN_SetSize,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangeLevel
+	FN_ChangeLevel,
+#else
+	NULL,
+#endif
+#ifdef FN_GetSpawnParms
+	FN_GetSpawnParms,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveSpawnParms
+	FN_SaveSpawnParms,
+#else
+	NULL,
+#endif
+#ifdef FN_VecToYaw
+	FN_VecToYaw,
+#else
+	NULL,
+#endif
+#ifdef FN_VecToAngles
+	FN_VecToAngles,
+#else
+	NULL,
+#endif
+#ifdef FN_MoveToOrigin
+	FN_MoveToOrigin,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangeYaw
+	FN_ChangeYaw,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangePitch
+	FN_ChangePitch,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityByString
+	FN_FindEntityByString,
+#else
+	NULL,
+#endif
+#ifdef FN_GetEntityIllum
+	FN_GetEntityIllum,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityInSphere
+	FN_FindEntityInSphere,
+#else
+	NULL,
+#endif
+#ifdef FN_FindClientInPVS
+	FN_FindClientInPVS,
+#else
+	NULL,
+#endif
+#ifdef FN_EntitiesInPVS
+	FN_EntitiesInPVS,
+#else
+	NULL,
+#endif
+#ifdef FN_MakeVectors
+	FN_MakeVectors,
+#else
+	NULL,
+#endif
+#ifdef FN_AngleVectors
+	FN_AngleVectors,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateEntity
+	FN_CreateEntity,
+#else
+	NULL,
+#endif
+#ifdef FN_RemoveEntity
+	FN_RemoveEntity,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateNamedEntity
+	FN_CreateNamedEntity,
+#else
+	NULL,
+#endif
+#ifdef FN_MakeStatic
+	FN_MakeStatic,
+#else
+	NULL,
+#endif
+#ifdef FN_EntIsOnFloor
+	FN_EntIsOnFloor,
+#else
+	NULL,
+#endif
+#ifdef FN_DropToFloor
+	FN_DropToFloor,
+#else
+	NULL,
+#endif
+#ifdef FN_WalkMove
+	FN_WalkMove,
+#else
+	NULL,
+#endif
+#ifdef FN_SetOrigin
+	FN_SetOrigin,
+#else
+	NULL,
+#endif
+#ifdef FN_EmitSound
+	FN_EmitSound,
+#else
+	NULL,
+#endif
+#ifdef FN_EmitAmbientSound
+	FN_EmitAmbientSound,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceLine
+	FN_TraceLine,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceToss
+	FN_TraceToss,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceMonsterHull
+	FN_TraceMonsterHull,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceHull
+	FN_TraceHull,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceModel
+	FN_TraceModel,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceTexture
+	FN_TraceTexture,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceSphere
+	FN_TraceSphere,
+#else
+	NULL,
+#endif
+#ifdef FN_GetAimVector
+	FN_GetAimVector,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerCommand
+	FN_ServerCommand,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerExecute
+	FN_ServerExecute,
+#else
+	NULL,
+#endif
+#ifdef FN_engClientCommand
+	FN_engClientCommand,
+#else
+	NULL,
+#endif
+#ifdef FN_ParticleEffect
+	FN_ParticleEffect,
+#else
+	NULL,
+#endif
+#ifdef FN_LightStyle
+	FN_LightStyle,
+#else
+	NULL,
+#endif
+#ifdef FN_DecalIndex
+	FN_DecalIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_PointContents
+	FN_PointContents,
+#else
+	NULL,
+#endif
+#ifdef FN_MessageBegin
+	FN_MessageBegin,
+#else
+	NULL,
+#endif
+#ifdef FN_MessageEnd
+	FN_MessageEnd,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteByte
+	FN_WriteByte,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteChar
+	FN_WriteChar,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteShort
+	FN_WriteShort,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteLong
+	FN_WriteLong,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteAngle
+	FN_WriteAngle,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteCoord
+	FN_WriteCoord,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteString
+	FN_WriteString,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteEntity
+	FN_WriteEntity,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarRegister
+	FN_CVarRegister,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetFloat
+	FN_CVarGetFloat,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetString
+	FN_CVarGetString,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarSetFloat
+	FN_CVarSetFloat,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarSetString
+	FN_CVarSetString,
+#else
+	NULL,
+#endif
+#ifdef FN_AlertMessage
+	FN_AlertMessage,
+#else
+	NULL,
+#endif
+#ifdef FN_EngineFprintf
+	FN_EngineFprintf,
+#else
+	NULL,
+#endif
+#ifdef FN_PvAllocEntPrivateData
+	FN_PvAllocEntPrivateData,
+#else
+	NULL,
+#endif
+#ifdef FN_PvEntPrivateData
+	FN_PvEntPrivateData,
+#else
+	NULL,
+#endif
+#ifdef FN_FreeEntPrivateData
+	FN_FreeEntPrivateData,
+#else
+	NULL,
+#endif
+#ifdef FN_SzFromIndex
+	FN_SzFromIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_AllocString
+	FN_AllocString,
+#else
+	NULL,
+#endif
+#ifdef FN_GetVarsOfEnt
+	FN_GetVarsOfEnt,
+#else
+	NULL,
+#endif
+#ifdef FN_PEntityOfEntOffset
+	FN_PEntityOfEntOffset,
+#else
+	NULL,
+#endif
+#ifdef FN_EntOffsetOfPEntity
+	FN_EntOffsetOfPEntity,
+#else
+	NULL,
+#endif
+#ifdef FN_IndexOfEdict
+	FN_IndexOfEdict,
+#else
+	NULL,
+#endif
+#ifdef FN_PEntityOfEntIndex
+	FN_PEntityOfEntIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityByVars
+	FN_FindEntityByVars,
+#else
+	NULL,
+#endif
+#ifdef FN_GetModelPtr
+	FN_GetModelPtr,
+#else
+	NULL,
+#endif
+#ifdef FN_RegUserMsg
+	FN_RegUserMsg,
+#else
+	NULL,
+#endif
+#ifdef FN_AnimationAutomove
+	FN_AnimationAutomove,
+#else
+	NULL,
+#endif
+#ifdef FN_GetBonePosition
+	FN_GetBonePosition,
+#else
+	NULL,
+#endif
+#ifdef FN_FunctionFromName
+	FN_FunctionFromName,
+#else
+	NULL,
+#endif
+#ifdef FN_NameForFunction
+	FN_NameForFunction,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientPrintf
+	FN_ClientPrintf,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerPrint
+	FN_ServerPrint,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Args
+	FN_Cmd_Args,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Argv
+	FN_Cmd_Argv,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Argc
+	FN_Cmd_Argc,
+#else
+	NULL,
+#endif
+#ifdef FN_GetAttachment
+	FN_GetAttachment,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_Init
+	FN_CRC32_Init,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_ProcessBuffer
+	FN_CRC32_ProcessBuffer,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_ProcessByte
+	FN_CRC32_ProcessByte,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_Final
+	FN_CRC32_Final,
+#else
+	NULL,
+#endif
+#ifdef FN_RandomLong
+	FN_RandomLong,
+#else
+	NULL,
+#endif
+#ifdef FN_RandomFloat
+	FN_RandomFloat,
+#else
+	NULL,
+#endif
+#ifdef FN_SetView
+	FN_SetView,
+#else
+	NULL,
+#endif
+#ifdef FN_Time
+	FN_Time,
+#else
+	NULL,
+#endif
+#ifdef FN_CrosshairAngle
+	FN_CrosshairAngle,
+#else
+	NULL,
+#endif
+#ifdef FN_LoadFileForMe
+	FN_LoadFileForMe,
+#else
+	NULL,
+#endif
+#ifdef FN_FreeFile
+	FN_FreeFile,
+#else
+	NULL,
+#endif
+#ifdef FN_EndSection
+	FN_EndSection,
+#else
+	NULL,
+#endif
+#ifdef FN_CompareFileTime
+	FN_CompareFileTime,
+#else
+	NULL,
+#endif
+#ifdef FN_GetGameDir
+	FN_GetGameDir,
+#else
+	NULL,
+#endif
+#ifdef FN_Cvar_RegisterVariable
+	FN_Cvar_RegisterVariable,
+#else
+	NULL,
+#endif
+#ifdef FN_FadeClientVolume
+	FN_FadeClientVolume,
+#else
+	NULL,
+#endif
+#ifdef FN_SetClientMaxspeed
+	FN_SetClientMaxspeed,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateFakeClient
+	FN_CreateFakeClient,
+#else
+	NULL,
+#endif
+#ifdef FN_RunPlayerMove
+	FN_RunPlayerMove,
+#else
+	NULL,
+#endif
+#ifdef FN_NumberOfEntities
+	FN_NumberOfEntities,
+#else
+	NULL,
+#endif
+#ifdef FN_GetInfoKeyBuffer
+	FN_GetInfoKeyBuffer,
+#else
+	NULL,
+#endif
+#ifdef FN_InfoKeyValue
+	FN_InfoKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_SetKeyValue
+	FN_SetKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_SetClientKeyValue
+	FN_SetClientKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_IsMapValid
+	FN_IsMapValid,
+#else
+	NULL,
+#endif
+#ifdef FN_StaticDecal
+	FN_StaticDecal,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheGeneric
+	FN_PrecacheGeneric,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerUserId
+	FN_GetPlayerUserId,
+#else
+	NULL,
+#endif
+#ifdef FN_BuildSoundMsg
+	FN_BuildSoundMsg,
+#else
+	NULL,
+#endif
+#ifdef FN_IsDedicatedServer
+	FN_IsDedicatedServer,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetPointer
+	FN_CVarGetPointer,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerWONId
+	FN_GetPlayerWONId,
+#else
+	NULL,
+#endif
+#ifdef FN_Info_RemoveKey
+	FN_Info_RemoveKey,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPhysicsKeyValue
+	FN_GetPhysicsKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_SetPhysicsKeyValue
+	FN_SetPhysicsKeyValue,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPhysicsInfoString
+	FN_GetPhysicsInfoString,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheEvent
+	FN_PrecacheEvent,
+#else
+	NULL,
+#endif
+#ifdef FN_PlaybackEvent
+	FN_PlaybackEvent,
+#else
+	NULL,
+#endif
+#ifdef FN_SetFatPVS
+	FN_SetFatPVS,
+#else
+	NULL,
+#endif
+#ifdef FN_SetFatPAS
+	FN_SetFatPAS,
+#else
+	NULL,
+#endif
+#ifdef FN_CheckVisibility
+	FN_CheckVisibility,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaSetField
+	FN_DeltaSetField,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaUnsetField
+	FN_DeltaUnsetField,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaAddEncoder
+	FN_DeltaAddEncoder,
+#else
+	NULL,
+#endif
+#ifdef FN_GetCurrentPlayer
+	FN_GetCurrentPlayer,
+#else
+	NULL,
+#endif
+#ifdef FN_CanSkipPlayer
+	FN_CanSkipPlayer,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaFindField
+	FN_DeltaFindField,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaSetFieldByIndex
+	FN_DeltaSetFieldByIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaUnsetFieldByIndex
+	FN_DeltaUnsetFieldByIndex,
+#else
+	NULL,
+#endif
+#ifdef FN_SetGroupMask
+	FN_SetGroupMask,
+#else
+	NULL,
+#endif
+#ifdef FN_engCreateInstancedBaseline
+	FN_engCreateInstancedBaseline,
+#else
+	NULL,
+#endif
+#ifdef FN_Cvar_DirectSet
+	FN_Cvar_DirectSet,
+#else
+	NULL,
+#endif
+#ifdef FN_ForceUnmodified
+	FN_ForceUnmodified,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerStats
+	FN_GetPlayerStats,
+#else
+	NULL,
+#endif
+#ifdef FN_AddServerCommand
+	FN_AddServerCommand,
+#else
+	NULL,
+#endif
+#ifdef FN_Voice_GetClientListening
+	FN_Voice_GetClientListening,
+#else
+	NULL,
+#endif
+#ifdef FN_Voice_SetClientListening
+	FN_Voice_SetClientListening,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerAuthId
+	FN_GetPlayerAuthId
+#else
+	NULL
+#endif
+}; // g_EngineFuncs_Table
+
+
+static enginefuncs_t g_EngineFuncs_Post_Table =
+{
+#ifdef FN_PrecacheModel_Post
+	FN_PrecacheModel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheSound_Post
+	FN_PrecacheSound_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetModel_Post
+	FN_SetModel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ModelIndex_Post
+	FN_ModelIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ModelFrames_Post
+	FN_ModelFrames_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetSize_Post
+	FN_SetSize_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangeLevel_Post
+	FN_ChangeLevel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetSpawnParms_Post
+	FN_GetSpawnParms_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SaveSpawnParms_Post
+	FN_SaveSpawnParms_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_VecToYaw_Post
+	FN_VecToYaw_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_VecToAngles_Post
+	FN_VecToAngles_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_MoveToOrigin_Post
+	FN_MoveToOrigin_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangeYaw_Post
+	FN_ChangeYaw_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ChangePitch_Post
+	FN_ChangePitch_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityByString_Post
+	FN_FindEntityByString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetEntityIllum_Post
+	FN_GetEntityIllum_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityInSphere_Post
+	FN_FindEntityInSphere_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FindClientInPVS_Post
+	FN_FindClientInPVS_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EntitiesInPVS_Post
+	FN_EntitiesInPVS_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_MakeVectors_Post
+	FN_MakeVectors_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AngleVectors_Post
+	FN_AngleVectors_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateEntity_Post
+	FN_CreateEntity_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RemoveEntity_Post
+	FN_RemoveEntity_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateNamedEntity_Post
+	FN_CreateNamedEntity_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_MakeStatic_Post
+	FN_MakeStatic_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EntIsOnFloor_Post
+	FN_EntIsOnFloor_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DropToFloor_Post
+	FN_DropToFloor_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WalkMove_Post
+	FN_WalkMove_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetOrigin_Post
+	FN_SetOrigin_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EmitSound_Post
+	FN_EmitSound_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EmitAmbientSound_Post
+	FN_EmitAmbientSound_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceLine_Post
+	FN_TraceLine_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceToss_Post
+	FN_TraceToss_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceMonsterHull_Post
+	FN_TraceMonsterHull_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceHull_Post
+	FN_TraceHull_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceModel_Post
+	FN_TraceModel_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceTexture_Post
+	FN_TraceTexture_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_TraceSphere_Post
+	FN_TraceSphere_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetAimVector_Post
+	FN_GetAimVector_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerCommand_Post
+	FN_ServerCommand_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerExecute_Post
+	FN_ServerExecute_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_engClientCommand_Post
+	FN_engClientCommand_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ParticleEffect_Post
+	FN_ParticleEffect_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_LightStyle_Post
+	FN_LightStyle_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DecalIndex_Post
+	FN_DecalIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PointContents_Post
+	FN_PointContents_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_MessageBegin_Post
+	FN_MessageBegin_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_MessageEnd_Post
+	FN_MessageEnd_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteByte_Post
+	FN_WriteByte_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteChar_Post
+	FN_WriteChar_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteShort_Post
+	FN_WriteShort_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteLong_Post
+	FN_WriteLong_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteAngle_Post
+	FN_WriteAngle_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteCoord_Post
+	FN_WriteCoord_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteString_Post
+	FN_WriteString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_WriteEntity_Post
+	FN_WriteEntity_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarRegister_Post
+	FN_CVarRegister_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetFloat_Post
+	FN_CVarGetFloat_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetString_Post
+	FN_CVarGetString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarSetFloat_Post
+	FN_CVarSetFloat_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarSetString_Post
+	FN_CVarSetString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AlertMessage_Post
+	FN_AlertMessage_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EngineFprintf_Post
+	FN_EngineFprintf_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PvAllocEntPrivateData_Post
+	FN_PvAllocEntPrivateData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PvEntPrivateData_Post
+	FN_PvEntPrivateData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FreeEntPrivateData_Post
+	FN_FreeEntPrivateData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SzFromIndex_Post
+	FN_SzFromIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AllocString_Post
+	FN_AllocString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetVarsOfEnt_Post
+	FN_GetVarsOfEnt_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PEntityOfEntOffset_Post
+	FN_PEntityOfEntOffset_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EntOffsetOfPEntity_Post
+	FN_EntOffsetOfPEntity_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_IndexOfEdict_Post
+	FN_IndexOfEdict_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PEntityOfEntIndex_Post
+	FN_PEntityOfEntIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FindEntityByVars_Post
+	FN_FindEntityByVars_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetModelPtr_Post
+	FN_GetModelPtr_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RegUserMsg_Post
+	FN_RegUserMsg_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AnimationAutomove_Post
+	FN_AnimationAutomove_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetBonePosition_Post
+	FN_GetBonePosition_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FunctionFromName_Post
+	FN_FunctionFromName_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_NameForFunction_Post
+	FN_NameForFunction_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ClientPrintf_Post
+	FN_ClientPrintf_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ServerPrint_Post
+	FN_ServerPrint_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Args_Post
+	FN_Cmd_Args_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Argv_Post
+	FN_Cmd_Argv_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Cmd_Argc_Post
+	FN_Cmd_Argc_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetAttachment_Post
+	FN_GetAttachment_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_Init_Post
+	FN_CRC32_Init_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_ProcessBuffer_Post
+	FN_CRC32_ProcessBuffer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_ProcessByte_Post
+	FN_CRC32_ProcessByte_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CRC32_Final_Post
+	FN_CRC32_Final_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RandomLong_Post
+	FN_RandomLong_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RandomFloat_Post
+	FN_RandomFloat_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetView_Post
+	FN_SetView_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Time_Post
+	FN_Time_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CrosshairAngle_Post
+	FN_CrosshairAngle_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_LoadFileForMe_Post
+	FN_LoadFileForMe_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FreeFile_Post
+	FN_FreeFile_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_EndSection_Post
+	FN_EndSection_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CompareFileTime_Post
+	FN_CompareFileTime_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetGameDir_Post
+	FN_GetGameDir_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Cvar_RegisterVariable_Post
+	FN_Cvar_RegisterVariable_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_FadeClientVolume_Post
+	FN_FadeClientVolume_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetClientMaxspeed_Post
+	FN_SetClientMaxspeed_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CreateFakeClient_Post
+	FN_CreateFakeClient_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_RunPlayerMove_Post
+	FN_RunPlayerMove_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_NumberOfEntities_Post
+	FN_NumberOfEntities_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetInfoKeyBuffer_Post
+	FN_GetInfoKeyBuffer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_InfoKeyValue_Post
+	FN_InfoKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetKeyValue_Post
+	FN_SetKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetClientKeyValue_Post
+	FN_SetClientKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_IsMapValid_Post
+	FN_IsMapValid_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_StaticDecal_Post
+	FN_StaticDecal_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheGeneric_Post
+	FN_PrecacheGeneric_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerUserId_Post
+	FN_GetPlayerUserId_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_BuildSoundMsg_Post
+	FN_BuildSoundMsg_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_IsDedicatedServer_Post
+	FN_IsDedicatedServer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CVarGetPointer_Post
+	FN_CVarGetPointer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerWONId_Post
+	FN_GetPlayerWONId_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Info_RemoveKey_Post
+	FN_Info_RemoveKey_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPhysicsKeyValue_Post
+	FN_GetPhysicsKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetPhysicsKeyValue_Post
+	FN_SetPhysicsKeyValue_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPhysicsInfoString_Post
+	FN_GetPhysicsInfoString_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PrecacheEvent_Post
+	FN_PrecacheEvent_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_PlaybackEvent_Post
+	FN_PlaybackEvent_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetFatPVS_Post
+	FN_SetFatPVS_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetFatPAS_Post
+	FN_SetFatPAS_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CheckVisibility_Post
+	FN_CheckVisibility_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaSetField_Post
+	FN_DeltaSetField_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaUnsetField_Post
+	FN_DeltaUnsetField_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaAddEncoder_Post
+	FN_DeltaAddEncoder_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetCurrentPlayer_Post
+	FN_GetCurrentPlayer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_CanSkipPlayer_Post
+	FN_CanSkipPlayer_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaFindField_Post
+	FN_DeltaFindField_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaSetFieldByIndex_Post
+	FN_DeltaSetFieldByIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_DeltaUnsetFieldByIndex_Post
+	FN_DeltaUnsetFieldByIndex_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_SetGroupMask_Post
+	FN_SetGroupMask_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_engCreateInstancedBaseline_Post
+	FN_engCreateInstancedBaseline_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Cvar_DirectSet_Post
+	FN_Cvar_DirectSet_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ForceUnmodified_Post
+	FN_ForceUnmodified_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerStats_Post
+	FN_GetPlayerStats_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_AddServerCommand_Post
+	FN_AddServerCommand_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Voice_GetClientListening_Post
+	FN_Voice_GetClientListening_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_Voice_SetClientListening_Post
+	FN_Voice_SetClientListening_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GetPlayerAuthId_Post
+	FN_GetPlayerAuthId_Post
+#else
+	NULL
+#endif
+}; // g_EngineFuncs_Post_Table
+
+
+static NEW_DLL_FUNCTIONS g_NewFuncs_Table = 
+{
+#ifdef FN_OnFreeEntPrivateData
+	FN_OnFreeEntPrivateData,
+#else
+	NULL,
+#endif
+#ifdef FN_GameShutdown
+	FN_GameShutdown,
+#else
+	NULL,
+#endif
+#ifdef FN_ShouldCollide
+	ShouldCollide,
+#else
+	NULL,
+#endif
+};
+
+
+static NEW_DLL_FUNCTIONS g_NewFuncs_Post_Table = 
+{
+#ifdef FN_OnFreeEntPrivateData_Post
+	FN_OnFreeEntPrivateData_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_GameShutdown_Post
+	FN_GameShutdown_Post,
+#else
+	NULL,
+#endif
+#ifdef FN_ShouldCollide_Post
+	ShouldCollide_Post,
+#else
+	NULL,
+#endif
+};
+
+// Global variables from metamod.  These variable names are referenced by
+// various macros.
+meta_globals_t *gpMetaGlobals;		// metamod globals
+gamedll_funcs_t *gpGamedllFuncs;	// gameDLL function tables
+mutil_funcs_t *gpMetaUtilFuncs;		// metamod utility functions
+
+
+plugin_info_t Plugin_info = {
+		META_INTERFACE_VERSION,
+		MODULE_NAME,
+		MODULE_VERSION,
+		MODULE_DATE,
+		MODULE_AUTHOR,
+		MODULE_URL,
+		MODULE_LOGTAG,
+		PT_ANYTIME,
+		PT_ANYTIME
+};
+
+/*
+C_DLLEXPORT int GetEntityAPI(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEntityAPI; version=%d", interfaceVersion);
+	if(!pFunctionTable) {
+		LOG_ERROR(PLID, "GetEntityAPI called with null pFunctionTable");
+		return(FALSE);
+	}
+	else if(interfaceVersion != INTERFACE_VERSION) {
+		LOG_ERROR(PLID, "GetEntityAPI version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION);
+		return(FALSE);
+	}
+	memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof( DLL_FUNCTIONS ) );
+
+	return (TRUE);
+}
+
+C_DLLEXPORT int GetEntityAPI_Post(DLL_FUNCTIONS *pFunctionTable, int interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEntityAPI_Post; version=%d", interfaceVersion);
+	if(!pFunctionTable) {
+		LOG_ERROR(PLID, "GetEntityAPI_Post called with null pFunctionTable");
+		return(FALSE);
+	}
+	else if(interfaceVersion != INTERFACE_VERSION) {
+		LOG_ERROR(PLID, "GetEntityAPI_Post version mismatch; requested=%d ours=%d", interfaceVersion, INTERFACE_VERSION);
+		return(FALSE);
+	}
+	memcpy(pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) );
+
+	return(TRUE);
+}
+*/
+
+C_DLLEXPORT int GetEntityAPI2(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEntityAPI2; version=%d", *interfaceVersion);
+	if(!pFunctionTable) {
+		LOG_ERROR(PLID, "GetEntityAPI2 called with null pFunctionTable");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != INTERFACE_VERSION) {
+		LOG_ERROR(PLID, 
+				"GetEntityAPI2 version mismatch; requested=%d ours=%d", 
+				*interfaceVersion, INTERFACE_VERSION);
+		//! Tell engine what version we had, so it can figure out who is 
+		//! out of date.
+		*interfaceVersion = INTERFACE_VERSION;
+		return(FALSE);
+	}
+	memcpy(pFunctionTable, &g_EntityAPI_Table, sizeof(DLL_FUNCTIONS));
+	g_pFunctionTable=pFunctionTable;
+	return(TRUE);
+}
+
+C_DLLEXPORT int GetEntityAPI2_Post(DLL_FUNCTIONS *pFunctionTable, int *interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEntityAPI2_Post; version=%d", *interfaceVersion);
+	if(!pFunctionTable) {
+		LOG_ERROR(PLID, "GetEntityAPI2_Post called with null pFunctionTable");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != INTERFACE_VERSION) {
+		LOG_ERROR(PLID, "GetEntityAPI2_Post version mismatch; requested=%d ours=%d", *interfaceVersion, INTERFACE_VERSION);
+		//! Tell engine what version we had, so it can figure out who is out of date.
+		*interfaceVersion = INTERFACE_VERSION;
+		return(FALSE);
+	}
+	memcpy( pFunctionTable, &g_EntityAPI_Post_Table, sizeof( DLL_FUNCTIONS ) );
+	g_pFunctionTable_Post=pFunctionTable;
+	return(TRUE);
+}
+
+C_DLLEXPORT int GetEngineFunctions(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEngineFunctions; version=%d", 
+			*interfaceVersion);
+	if(!pengfuncsFromEngine) {
+		LOG_ERROR(PLID, 
+				"GetEngineFunctions called with null pengfuncsFromEngine");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) {
+		LOG_ERROR(PLID, 
+				"GetEngineFunctions version mismatch; requested=%d ours=%d", 
+				*interfaceVersion, ENGINE_INTERFACE_VERSION);
+		// Tell metamod what version we had, so it can figure out who is 
+		// out of date.
+		*interfaceVersion = ENGINE_INTERFACE_VERSION;
+		return(FALSE);
+	}
+	memcpy(pengfuncsFromEngine, &g_EngineFuncs_Table, sizeof(enginefuncs_t));
+	g_pengfuncsTable=pengfuncsFromEngine;
+	return TRUE;
+}
+
+C_DLLEXPORT int GetEngineFunctions_Post(enginefuncs_t *pengfuncsFromEngine, int *interfaceVersion)
+{
+	LOG_DEVELOPER(PLID, "called: GetEngineFunctions_Post; version=%d", *interfaceVersion);
+	if(!pengfuncsFromEngine) {
+		LOG_ERROR(PLID, "GetEngineFunctions_Post called with null pengfuncsFromEngine");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != ENGINE_INTERFACE_VERSION) {
+		LOG_ERROR(PLID, "GetEngineFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, ENGINE_INTERFACE_VERSION);
+		// Tell metamod what version we had, so it can figure out who is out of date.
+		*interfaceVersion = ENGINE_INTERFACE_VERSION;
+		return(FALSE);
+	}
+	memcpy(pengfuncsFromEngine, &g_EngineFuncs_Post_Table, sizeof(enginefuncs_t));
+	g_pengfuncsTable_Post=pengfuncsFromEngine;
+	return TRUE;
+
+}
+
+C_DLLEXPORT int GetNewDLLFunctions(NEW_DLL_FUNCTIONS *pNewFunctionTable, 
+		int *interfaceVersion) 
+{
+	LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions; version=%d", 
+			*interfaceVersion);
+	if(!pNewFunctionTable) {
+		LOG_ERROR(PLID, 
+				"GetNewDLLFunctions called with null pNewFunctionTable");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) {
+		LOG_ERROR(PLID, 
+				"GetNewDLLFunctions version mismatch; requested=%d ours=%d", 
+				*interfaceVersion, NEW_DLL_FUNCTIONS_VERSION);
+		//! Tell engine what version we had, so it can figure out who is 
+		//! out of date.
+		*interfaceVersion = NEW_DLL_FUNCTIONS_VERSION;
+		return(FALSE);
+	}
+	memcpy(pNewFunctionTable, &g_NewFuncs_Table, sizeof(NEW_DLL_FUNCTIONS));
+	g_pNewFunctionsTable=pNewFunctionTable;
+	return TRUE;
+}
+
+C_DLLEXPORT int GetNewDLLFunctions_Post( NEW_DLL_FUNCTIONS *pNewFunctionTable, int *interfaceVersion ) 
+{
+	LOG_DEVELOPER(PLID, "called: GetNewDLLFunctions_Post; version=%d", *interfaceVersion);
+	if(!pNewFunctionTable) {
+		LOG_ERROR(PLID, "GetNewDLLFunctions_Post called with null pNewFunctionTable");
+		return(FALSE);
+	}
+	else if(*interfaceVersion != NEW_DLL_FUNCTIONS_VERSION) {
+		LOG_ERROR(PLID, "GetNewDLLFunctions_Post version mismatch; requested=%d ours=%d", *interfaceVersion, NEW_DLL_FUNCTIONS_VERSION);
+		//! Tell engine what version we had, so it can figure out who is out of date.
+		*interfaceVersion = NEW_DLL_FUNCTIONS_VERSION;
+		return(FALSE);
+	}
+	memcpy(pNewFunctionTable, &g_NewFuncs_Post_Table, sizeof(NEW_DLL_FUNCTIONS));
+	g_pNewFunctionsTable_Post=pNewFunctionTable;
+	return TRUE;
+}
+
+
+static META_FUNCTIONS g_MetaFunctions_Table =
+{
+	NULL,
+	NULL,
+	GetEntityAPI2,
+	GetEntityAPI2_Post,
+	GetNewDLLFunctions,
+	GetNewDLLFunctions_Post,
+	GetEngineFunctions,
+	GetEngineFunctions_Post
+};
+
+C_DLLEXPORT int Meta_Query(char *ifvers, plugin_info_t **pPlugInfo, mutil_funcs_t *pMetaUtilFuncs)
+{
+	if ((int) CVAR_GET_FLOAT("developer") != 0)
+		UTIL_LogPrintf("[%s] dev: called: Meta_Query; version=%s, ours=%s\n", 
+				Plugin_info.logtag, ifvers, Plugin_info.ifvers);
+
+	// Check for valid pMetaUtilFuncs before we continue.
+	if(!pMetaUtilFuncs) {
+		UTIL_LogPrintf("[%s] ERROR: Meta_Query called with null pMetaUtilFuncs\n", Plugin_info.logtag);
+		return(FALSE);
+	}
+
+	gpMetaUtilFuncs = pMetaUtilFuncs;
+
+	*pPlugInfo = &Plugin_info;
+
+	// Check for interface version compatibility.
+	if(!FStrEq(ifvers, Plugin_info.ifvers)) {
+		int mmajor=0, mminor=0, pmajor=0, pminor=0;
+		LOG_MESSAGE(PLID, "WARNING: meta-interface version mismatch; requested=%s ours=%s",
+				Plugin_info.logtag, ifvers);
+		// If plugin has later interface version, it's incompatible (update
+		// metamod).
+		sscanf(ifvers, "%d:%d", &mmajor, &mminor);
+		sscanf(META_INTERFACE_VERSION, "%d:%d", &pmajor, &pminor);
+		if(pmajor > mmajor || (pmajor==mmajor && pminor > mminor)) {
+			LOG_ERROR(PLID, "metamod version is too old for this module; update metamod");
+			return(FALSE);
+		}
+		// If plugin has older major interface version, it's incompatible
+		// (update plugin).
+		else if(pmajor < mmajor) {
+			LOG_ERROR(PLID, "metamod version is incompatible with this module; please find a newer version of this module");
+			return(FALSE);
+		}
+		// Minor interface is older, but this is guaranteed to be backwards
+		// compatible, so we warn, but we still accept it.
+		else if(pmajor==mmajor && pminor < mminor)
+			LOG_MESSAGE(PLID, "WARNING: metamod version is newer than expected; consider finding a newer version of this module");
+		else
+			LOG_ERROR(PLID, "unexpected version comparison; metavers=%s, mmajor=%d, mminor=%d; plugvers=%s, pmajor=%d, pminor=%d", ifvers, mmajor, mminor, META_INTERFACE_VERSION, pmajor, pminor);
+	}
+
+#ifdef FN_META_QUERY
+	return FN_META_QUERY();
+#endif	// FN_META_QUERY
+
+	return 1;
+}
+
+
+C_DLLEXPORT int Meta_Attach(PLUG_LOADTIME now, META_FUNCTIONS *pFunctionTable, meta_globals_t *pMGlobals, gamedll_funcs_t *pGamedllFuncs)
+{
+	if(now > Plugin_info.loadable) {
+		LOG_ERROR(PLID, "Can't load module right now");
+		return(FALSE);
+	}
+	if(!pMGlobals) {
+		LOG_ERROR(PLID, "Meta_Attach called with null pMGlobals");
+		return(FALSE);
+	}
+	gpMetaGlobals=pMGlobals;
+	if(!pFunctionTable) {
+		LOG_ERROR(PLID, "Meta_Attach called with null pFunctionTable");
+		return(FALSE);
+	}
+
+	memcpy(pFunctionTable, &g_MetaFunctions_Table, sizeof(META_FUNCTIONS));
+	gpGamedllFuncs=pGamedllFuncs;
+
+	// Let's go.
+
+#ifdef FN_META_ATTACH
+	FN_META_ATTACH();
+#endif	// FN_META_ATTACH
+
+	return TRUE;
+}
+
+C_DLLEXPORT int Meta_Detach(PLUG_LOADTIME now, PL_UNLOAD_REASON reason)
+{
+	if(now > Plugin_info.unloadable && reason != PNL_CMD_FORCED) {
+		LOG_ERROR(PLID, "Can't unload plugin right now");
+		return(FALSE);
+	}
+
+#ifdef FN_META_DETACH
+	return FN_META_DETACH();
+#endif	// FN_META_DETACH
+	return TRUE;
+}
+
+
+
+#ifdef __linux__
+// linux prototype
+C_DLLEXPORT void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals ) {
+
+#else
+#ifdef _MSC_VER
+// MSVC: Simulate __stdcall calling convention
+C_DLLEXPORT __declspec(naked) void GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
+{
+	__asm			// Prolog
+	{
+		// Save ebp
+		push		ebp
+		// Set stack frame pointer
+		mov			ebp, esp
+		// Allocate space for local variables
+		// The MSVC compiler gives us the needed size in __LOCAL_SIZE.
+		sub			esp, __LOCAL_SIZE
+		// Push registers
+		push		ebx
+		push		esi
+		push		edi
+	}
+#else	// _MSC_VER
+#ifdef __GNUC__
+// GCC can also work with this
+C_DLLEXPORT void __stdcall GiveFnptrsToDll( enginefuncs_t* pengfuncsFromEngine, globalvars_t *pGlobals )
+{
+#else	// __GNUC__
+// compiler not known
+#error There is no support (yet) for your compiler. Please use MSVC or GCC compilers or contact the AMX Mod X dev team.
+#endif	// __GNUC__
+#endif // _MSC_VER
+#endif // __linux__
+
+	// ** Function core <--
+	memcpy(&g_engfuncs, pengfuncsFromEngine, sizeof(enginefuncs_t));
+	gpGlobals = pGlobals;
+	// NOTE!  Have to call logging function _after_ copying into g_engfuncs, so
+	// that g_engfuncs.pfnAlertMessage() can be resolved properly, heh. :)
+	UTIL_LogPrintf("[%s] dev: called: GiveFnptrsToDll\n", Plugin_info.logtag);
+	// --> ** Function core
+
+#ifdef _MSC_VER
+	// Epilog
+	if (sizeof(int*) == 8)
+	{	// 64 bit
+		__asm
+		{
+			// Pop registers
+			pop	edi
+			pop	esi
+			pop	ebx
+			// Restore stack frame pointer
+			mov	esp, ebp
+			// Restore ebp
+			pop	ebp
+			// 2 * sizeof(int*) = 16 on 64 bit
+			ret 16
+		}
+	}
+	else
+	{	// 32 bit
+		__asm
+		{
+			// Pop registers
+			pop	edi
+			pop	esi
+			pop	ebx
+			// Restore stack frame pointer
+			mov	esp, ebp
+			// Restore ebp
+			pop	ebp
+			// 2 * sizeof(int*) = 8 on 32 bit
+			ret 8
+		}
+	}
+#endif // #ifdef _MSC_VER
+}
+
+#endif	// #ifdef USE_METAMOD
+
+/************* AMXX Stuff *************/
+
+// *** Types ***
+typedef void* (*PFN_REQ_FNPTR)(const char * /*name*/);
+
+// *** Globals ***
+// Module info
+static amxx_module_info_s g_ModuleInfo = 
+{
+	MODULE_NAME,
+	MODULE_AUTHOR,
+	MODULE_VERSION,
+#ifdef MODULE_RELOAD_ON_MAPCHANGE
+	1
+#else // MODULE_RELOAD_ON_MAPCHANGE
+	0
+#endif // MODULE_RELOAD_ON_MAPCHANGE
+};
+
+// Storage for the requested functions
+PFN_ADD_NATIVES				g_fn_AddNatives;
+PFN_BUILD_PATHNAME			g_fn_BuildPathname;
+PFN_GET_AMXADDR				g_fn_GetAmxAddr;
+PFN_PRINT_SRVCONSOLE		g_fn_PrintSrvConsole;
+PFN_GET_MODNAME				g_fn_GetModname;
+PFN_GET_AMXSCRIPTNAME		g_fn_GetAmxScriptName;
+PFN_GET_AMXSCRIPT			g_fn_GetAmxScript;
+PFN_FIND_AMXSCRIPT_BYAMX	g_fn_FindAmxScriptByAmx;
+PFN_FIND_AMXSCRIPT_BYNAME	g_fn_FindAmxScriptByName;
+PFN_SET_AMXSTRING			g_fn_SetAmxString;
+PFN_GET_AMXSTRING			g_fn_GetAmxString;
+PFN_GET_AMXSTRINGLEN		g_fn_GetAmxStringLen;
+PFN_FORMAT_AMXSTRING		g_fn_FormatAmxString;
+PFN_COPY_AMXMEMORY			g_fn_CopyAmxMemory;
+PFN_LOG						g_fn_Log;
+PFN_LOG_ERROR				g_fn_LogErrorFunc;
+PFN_RAISE_AMXERROR			g_fn_RaiseAmxError;
+PFN_REGISTER_FORWARD		g_fn_RegisterForward;
+PFN_EXECUTE_FORWARD			g_fn_ExecuteForward;
+PFN_PREPARE_CELLARRAY		g_fn_PrepareCellArray;
+PFN_PREPARE_CHARARRAY		g_fn_PrepareCharArray;
+PFN_PREPARE_CELLARRAY_A		g_fn_PrepareCellArrayA;
+PFN_PREPARE_CHARARRAY_A		g_fn_PrepareCharArrayA;
+PFN_IS_PLAYER_VALID			g_fn_IsPlayerValid;
+PFN_GET_PLAYER_NAME			g_fn_GetPlayerName;
+PFN_GET_PLAYER_IP			g_fn_GetPlayerIP;
+PFN_IS_PLAYER_INGAME		g_fn_IsPlayerIngame;
+PFN_IS_PLAYER_BOT			g_fn_IsPlayerBot;
+PFN_IS_PLAYER_AUTHORIZED	g_fn_IsPlayerAuthorized;
+PFN_GET_PLAYER_TIME			g_fn_GetPlayerTime;
+PFN_GET_PLAYER_PLAYTIME		g_fn_GetPlayerPlayTime;
+PFN_GET_PLAYER_CURWEAPON	g_fn_GetPlayerCurweapon;
+PFN_GET_PLAYER_TEAM			g_fn_GetPlayerTeam;
+PFN_GET_PLAYER_TEAMID		g_fn_GetPlayerTeamID;
+PFN_GET_PLAYER_DEATHS		g_fn_GetPlayerDeaths;
+PFN_GET_PLAYER_MENU			g_fn_GetPlayerMenu;
+PFN_GET_PLAYER_KEYS			g_fn_GetPlayerKeys;
+PFN_IS_PLAYER_ALIVE			g_fn_IsPlayerAlive;
+PFN_GET_PLAYER_FRAGS		g_fn_GetPlayerFrags;
+PFN_IS_PLAYER_CONNECTING	g_fn_IsPlayerConnecting;
+PFN_IS_PLAYER_HLTV			g_fn_IsPlayerHLTV;
+PFN_GET_PLAYER_ARMOR		g_fn_GetPlayerArmor;
+PFN_GET_PLAYER_HEALTH		g_fn_GetPlayerHealth;
+PFN_ALLOCATOR				g_fn_Allocator;
+PFN_REALLOCATOR				g_fn_Reallocator;
+PFN_DEALLOCATOR				g_fn_Deallocator;
+PFN_AMX_EXEC				g_fn_AmxExec;
+PFN_AMX_EXECV				g_fn_AmxExecv;
+PFN_AMX_ALLOT				g_fn_AmxAllot;
+PFN_AMX_FINDPUBLIC			g_fn_AmxFindPublic;
+PFN_LOAD_AMXSCRIPT			g_fn_LoadAmxScript;
+PFN_UNLOAD_AMXSCRIPT		g_fn_UnloadAmxScript;
+PFN_REAL_TO_CELL			g_fn_RealToCell;
+PFN_CELL_TO_REAL			g_fn_CellToReal;
+PFN_REGISTER_SPFORWARD		g_fn_RegisterSPForward;
+PFN_REGISTER_SPFORWARD_BYNAME	g_fn_RegisterSPForwardByName;
+PFN_UNREGISTER_SPFORWARD	g_fn_UnregisterSPForward;
+PFN_MERGEDEFINITION_FILE	g_fn_MergeDefinition_File;
+PFN_AMX_FINDNATIVE			g_fn_AmxFindNative;
+PFN_GETPLAYERFLAGS			g_fn_GetPlayerFlags;
+PFN_GET_PLAYER_EDICT		g_fn_GetPlayerEdict;
+PFN_FORMAT					g_fn_Format;
+
+// *** Exports ***
+C_DLLEXPORT int AMXX_Query(int *interfaceVersion, amxx_module_info_s *moduleInfo)
+{
+	// check parameters
+	if (!interfaceVersion || !moduleInfo)
+		return AMXX_PARAM;
+
+	// check interface version
+	if (*interfaceVersion != AMXX_INTERFACE_VERSION)
+	{
+		// Tell amxx core our interface version
+		*interfaceVersion = AMXX_INTERFACE_VERSION;
+		return AMXX_IFVERS;
+	}
+
+	// copy module info
+	memcpy(moduleInfo, &g_ModuleInfo, sizeof(amxx_module_info_s));
+
+#ifdef FN_AMXX_QUERY
+	FN_AMXX_QUERY();
+#endif // FN_AMXX_QUERY
+	// Everything ok :)
+	return AMXX_OK;
+}
+
+// request function
+#define REQFUNC(name, fptr, type) if ((fptr = (type)reqFnptrFunc(name)) == 0) return AMXX_FUNC_NOT_PRESENT
+// request optional function
+#define REQFUNC_OPT(name, fptr, type) fptr = (type)reqFnptrFunc(name)
+
+C_DLLEXPORT int AMXX_Attach(PFN_REQ_FNPTR reqFnptrFunc)
+{
+	// Check pointer
+	if (!reqFnptrFunc)
+		return AMXX_PARAM;
+
+	// Req all known functions
+	// Misc
+	REQFUNC("BuildPathname", g_fn_BuildPathname, PFN_BUILD_PATHNAME);
+	REQFUNC("PrintSrvConsole", g_fn_PrintSrvConsole, PFN_PRINT_SRVCONSOLE);
+	REQFUNC("GetModname", g_fn_GetModname, PFN_GET_MODNAME);
+	REQFUNC("Log", g_fn_Log, PFN_LOG);
+	REQFUNC("LogError", g_fn_LogErrorFunc, PFN_LOG_ERROR);
+	REQFUNC("MergeDefinitionFile", g_fn_MergeDefinition_File, PFN_MERGEDEFINITION_FILE);
+	REQFUNC("Format", g_fn_Format, PFN_FORMAT);
+
+	// Amx scripts
+	REQFUNC("GetAmxScript", g_fn_GetAmxScript, PFN_GET_AMXSCRIPT);
+	REQFUNC("FindAmxScriptByAmx", g_fn_FindAmxScriptByAmx, PFN_FIND_AMXSCRIPT_BYAMX);
+	REQFUNC("FindAmxScriptByName", g_fn_FindAmxScriptByName, PFN_FIND_AMXSCRIPT_BYNAME);
+	REQFUNC("LoadAmxScript", g_fn_LoadAmxScript, PFN_LOAD_AMXSCRIPT);
+	REQFUNC("UnloadAmxScript", g_fn_UnloadAmxScript, PFN_UNLOAD_AMXSCRIPT);
+    REQFUNC("GetAmxScriptName", g_fn_GetAmxScriptName, PFN_GET_AMXSCRIPTNAME);
+
+	// String / mem in amx scripts support
+	REQFUNC("SetAmxString", g_fn_SetAmxString, PFN_SET_AMXSTRING);
+	REQFUNC("GetAmxString", g_fn_GetAmxString, PFN_GET_AMXSTRING);
+	REQFUNC("GetAmxStringLen", g_fn_GetAmxStringLen, PFN_GET_AMXSTRINGLEN);
+	REQFUNC("FormatAmxString", g_fn_FormatAmxString, PFN_FORMAT_AMXSTRING);
+	REQFUNC("CopyAmxMemory", g_fn_CopyAmxMemory, PFN_COPY_AMXMEMORY);
+	REQFUNC("GetAmxAddr", g_fn_GetAmxAddr, PFN_GET_AMXADDR);
+
+	REQFUNC("amx_Exec", g_fn_AmxExec, PFN_AMX_EXEC);
+	REQFUNC("amx_Execv", g_fn_AmxExecv, PFN_AMX_EXECV);
+	REQFUNC("amx_FindPublic", g_fn_AmxFindPublic, PFN_AMX_FINDPUBLIC);
+	REQFUNC("amx_Allot", g_fn_AmxAllot, PFN_AMX_ALLOT);
+	REQFUNC("amx_FindNative", g_fn_AmxFindNative, PFN_AMX_FINDNATIVE);
+
+	// Natives / Forwards
+	REQFUNC("AddNatives", g_fn_AddNatives, PFN_ADD_NATIVES);
+	REQFUNC("RaiseAmxError", g_fn_RaiseAmxError, PFN_RAISE_AMXERROR);
+	REQFUNC("RegisterForward", g_fn_RegisterForward, PFN_REGISTER_FORWARD);
+	REQFUNC("RegisterSPForward", g_fn_RegisterSPForward, PFN_REGISTER_SPFORWARD);
+	REQFUNC("RegisterSPForwardByName", g_fn_RegisterSPForwardByName, PFN_REGISTER_SPFORWARD_BYNAME);
+	REQFUNC("UnregisterSPForward", g_fn_UnregisterSPForward, PFN_UNREGISTER_SPFORWARD);
+	REQFUNC("ExecuteForward", g_fn_ExecuteForward, PFN_EXECUTE_FORWARD);
+	REQFUNC("PrepareCellArray", g_fn_PrepareCellArray, PFN_PREPARE_CELLARRAY);
+	REQFUNC("PrepareCharArray", g_fn_PrepareCharArray, PFN_PREPARE_CHARARRAY);
+	REQFUNC("PrepareCellArrayA", g_fn_PrepareCellArrayA, PFN_PREPARE_CELLARRAY_A);
+	REQFUNC("PrepareCharArrayA", g_fn_PrepareCharArrayA, PFN_PREPARE_CHARARRAY_A);
+	// Player
+	REQFUNC("IsPlayerValid", g_fn_IsPlayerValid, PFN_IS_PLAYER_VALID);
+	REQFUNC("GetPlayerName", g_fn_GetPlayerName, PFN_GET_PLAYER_NAME);
+	REQFUNC("GetPlayerIP", g_fn_GetPlayerIP, PFN_GET_PLAYER_IP);
+	REQFUNC("IsPlayerInGame", g_fn_IsPlayerIngame, PFN_IS_PLAYER_INGAME);		
+	REQFUNC("IsPlayerBot", g_fn_IsPlayerBot, PFN_IS_PLAYER_BOT);	
+	REQFUNC("IsPlayerAuthorized", g_fn_IsPlayerAuthorized, PFN_IS_PLAYER_AUTHORIZED);
+	REQFUNC("GetPlayerTime", g_fn_GetPlayerTime, PFN_GET_PLAYER_TIME);
+	REQFUNC("GetPlayerPlayTime", g_fn_GetPlayerPlayTime, PFN_GET_PLAYER_PLAYTIME);
+	REQFUNC("GetPlayerCurweapon", g_fn_GetPlayerCurweapon, PFN_GET_PLAYER_CURWEAPON);
+	REQFUNC("GetPlayerTeamID", g_fn_GetPlayerTeamID, PFN_GET_PLAYER_TEAMID);
+	REQFUNC("GetPlayerTeam",g_fn_GetPlayerTeam, PFN_GET_PLAYER_TEAM);
+	REQFUNC("GetPlayerDeaths", g_fn_GetPlayerDeaths, PFN_GET_PLAYER_DEATHS);
+	REQFUNC("GetPlayerMenu", g_fn_GetPlayerMenu, PFN_GET_PLAYER_MENU);
+	REQFUNC("GetPlayerKeys", g_fn_GetPlayerKeys, PFN_GET_PLAYER_KEYS);
+	REQFUNC("IsPlayerAlive", g_fn_IsPlayerAlive, PFN_IS_PLAYER_ALIVE);
+	REQFUNC("GetPlayerFrags", g_fn_GetPlayerFrags, PFN_GET_PLAYER_FRAGS);
+	REQFUNC("IsPlayerConnecting", g_fn_IsPlayerConnecting, PFN_IS_PLAYER_CONNECTING);
+	REQFUNC("IsPlayerHLTV", g_fn_IsPlayerHLTV, PFN_IS_PLAYER_HLTV);
+	REQFUNC("GetPlayerArmor", g_fn_GetPlayerArmor, PFN_GET_PLAYER_ARMOR);
+	REQFUNC("GetPlayerHealth", g_fn_GetPlayerHealth, PFN_GET_PLAYER_HEALTH);
+	REQFUNC("GetPlayerFlags", g_fn_GetPlayerFlags, PFN_GETPLAYERFLAGS);
+	REQFUNC("GetPlayerEdict", g_fn_GetPlayerEdict, PFN_GET_PLAYER_EDICT);
+
+	// Memory
+	REQFUNC_OPT("Allocator", g_fn_Allocator, PFN_ALLOCATOR);
+	REQFUNC_OPT("Reallocator", g_fn_Reallocator, PFN_REALLOCATOR);
+	REQFUNC_OPT("Deallocator", g_fn_Deallocator, PFN_DEALLOCATOR);
+
+	REQFUNC("CellToReal", g_fn_CellToReal, PFN_CELL_TO_REAL);
+	REQFUNC("RealToCell", g_fn_RealToCell, PFN_REAL_TO_CELL);
+
+#ifdef FN_AMXX_ATTACH
+	FN_AMXX_ATTACH();
+#endif // FN_AMXX_ATACH
+
+	return AMXX_OK;
+}
+
+C_DLLEXPORT int AMXX_Detach()
+{
+#ifdef FN_AMXX_DETACH
+	FN_AMXX_DETACH();
+#endif // FN_AMXX_DETACH
+
+	return AMXX_OK;
+}
+
+C_DLLEXPORT int AMXX_PluginsLoaded()
+{
+#ifdef FN_AMXX_PLUGINSLOADED
+	FN_AMXX_PLUGINSLOADED();
+#endif // FN_AMXX_PLUGINSLOADED
+	return AMXX_OK;
+}
+
+// Advanced MF functions
+void MF_Log(const char *fmt, ...)
+{
+	// :TODO: Overflow possible here
+	char msg[3072];
+	va_list arglst;
+	va_start(arglst, fmt);
+	vsprintf(msg, fmt, arglst);
+	va_end(arglst);
+
+	g_fn_Log("[%s] %s", MODULE_NAME, msg);
+}
+
+void MF_LogError(AMX *amx, int err, const char *fmt, ...)
+{
+	// :TODO: Overflow possible here
+	char msg[3072];
+	va_list arglst;
+	va_start(arglst, fmt);
+	vsprintf(msg, fmt, arglst);
+	va_end(arglst);
+
+	g_fn_LogErrorFunc(amx, err, "[%s] %s", MODULE_NAME, msg);
+}
+
+
+#ifdef _DEBUG
+// validate macros
+// Makes sure compiler reports errors when macros are invalid
+void ValidateMacros_DontCallThis_Smiley()
+{
+	MF_BuildPathname("str", "str", 0);
+	MF_FormatAmxString(NULL, 0, 0, NULL);
+	MF_GetAmxAddr(NULL, 0);
+	MF_PrintSrvConsole("str", "str", 0);
+	MF_GetModname();
+	MF_GetScriptName(0);
+	MF_GetScriptAmx(0);
+	MF_FindScriptByAmx(NULL);
+	MF_FindScriptByName("str");
+	MF_SetAmxString(NULL, 0, "str", 0);
+	MF_GetAmxString(NULL, 0, 0, 0);
+	MF_GetAmxStringLen(NULL);
+	MF_CopyAmxMemory(NULL, NULL, 0);
+	MF_Log("str", "str", 0);
+	MF_LogError(NULL, 0, NULL);
+	MF_RaiseAmxError(NULL, 0);
+	MF_RegisterForward("str", (ForwardExecType)0, 0, 0, 0);
+	MF_ExecuteForward(0, 0, 0);
+	MF_PrepareCellArray(NULL, 0);
+	MF_PrepareCharArray(NULL, 0);
+	MF_PrepareCellArrayA(NULL, 0, true);
+	MF_PrepareCharArrayA(NULL, 0, true);
+	MF_IsPlayerValid(0);
+	MF_GetPlayerName(0);
+	MF_GetPlayerIP(0);
+	MF_IsPlayerIngame(0);
+	MF_IsPlayerBot(0);
+	MF_IsPlayerAuthorized(0);
+	MF_GetPlayerTime(0);
+	MF_GetPlayerPlayTime(0);
+	MF_GetPlayerCurweapon(0);
+	MF_GetPlayerTeamID(0);
+	MF_GetPlayerTeam(0);
+	MF_GetPlayerDeaths(0);
+	MF_GetPlayerMenu(0);
+	MF_GetPlayerKeys(0);
+	MF_IsPlayerAlive(0);
+	MF_GetPlayerFrags(0);
+	MF_IsPlayerConnecting(0);
+	MF_IsPlayerHLTV(0);
+	MF_GetPlayerArmor(0);
+	MF_GetPlayerHealth(0);
+	MF_AmxExec(0, 0, 0, 0);
+	MF_AmxExecv(0, 0, 0, 0, 0);
+	MF_AmxFindPublic(0, 0, 0);
+	MF_AmxAllot(0, 0, 0, 0);
+	MF_LoadAmxScript(0, 0, 0, 0, 0);
+	MF_UnloadAmxScript(0, 0);
+	MF_RegisterSPForward(0, 0, 0, 0, 0, 0);
+	MF_RegisterSPForwardByName(0, 0, 0, 0, 0, 0);
+	MF_UnregisterSPForward(0);
+	MF_GetPlayerFrags(0);
+	MF_GetPlayerEdict(0);
+	MF_Format("", 4, "str");
+}
+#endif
+
+/************* MEMORY *************/
+// undef all defined macros
+#undef new
+#undef delete
+#undef malloc
+#undef calloc
+#undef realloc
+#undef free
+
+const		unsigned int	m_alloc_unknown        = 0;
+const		unsigned int	m_alloc_new            = 1;
+const		unsigned int	m_alloc_new_array      = 2;
+const		unsigned int	m_alloc_malloc         = 3;
+const		unsigned int	m_alloc_calloc         = 4;
+const		unsigned int	m_alloc_realloc        = 5;
+const		unsigned int	m_alloc_delete         = 6;
+const		unsigned int	m_alloc_delete_array   = 7;
+const		unsigned int	m_alloc_free           = 8;
+
+const char *g_Mem_CurrentFilename = "??";
+int g_Mem_CurrentLine = 0;
+const char *g_Mem_CurrentFunc = "??";
+
+const char *Mem_MakeSourceFile(const char *sourceFile)
+{
+	static char buffer[512];
+	static size_t pos = 0;
+	if (!pos)
+	{
+		// init
+		buffer[0] = '[';
+		strcpy(buffer + 1, MODULE_NAME);
+		pos = strlen(MODULE_NAME) + 1;
+		buffer[pos++] = ']';
+	}
+
+	// convert from absolute path to [modulename]filename
+	const char *ptr = strrchr(sourceFile, '\\');
+	if (ptr)
+		ptr++;
+	else
+	{
+		ptr = strrchr(sourceFile, '/');
+		if (ptr)
+			ptr++;
+		else
+			ptr = sourceFile;
+	}
+	strcpy(buffer + pos, ptr);
+	return buffer;
+}
+
+void Mem_SetOwner(const char *filename, int line, const char *function)
+{
+	g_Mem_CurrentFilename = filename;
+	g_Mem_CurrentLine = line;
+	g_Mem_CurrentFunc = function;
+}
+
+void Mem_ResetGlobals()
+{
+	Mem_SetOwner("??", 0, "??");
+}
+
+// raw (re/de)allocators
+void *	Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+			     const unsigned int allocationType, const size_t reportedSize)
+{
+	if (g_fn_Allocator)
+		return g_fn_Allocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, allocationType, reportedSize);
+	else
+		return malloc(reportedSize);
+}
+
+void *	Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+			       const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress)
+{
+	if (g_fn_Reallocator)
+		return g_fn_Reallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, reallocationType, reportedSize, reportedAddress);
+	else
+		return realloc(reportedAddress, reportedSize);
+}
+
+void	Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+			      const unsigned int deallocationType, void *reportedAddress)
+{
+	// If you you get user breakpoint here, something failed :)
+	//  - invalid pointer
+	//  - alloc type mismatch	( for example
+	//							char *a = new char[5]; delete char;
+	//							)
+	//  - The allocation unit is damaged (for example
+	//							char *a = new char[5]; a[6] = 8;
+	//							)
+	//  - break on dealloc flag set (somehow)
+
+	if (g_fn_Deallocator)
+		g_fn_Deallocator(Mem_MakeSourceFile(sourceFile), sourceLine, sourceFunc, deallocationType, reportedAddress);
+	else
+		free(reportedAddress);
+}
+
+// new and delete operators
+void	*operator new(size_t reportedSize)
+{
+	if (reportedSize == 0)
+		reportedSize = 1;
+	void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize);
+	// :TODO: Handler support ?
+	if (ptr)
+		return ptr;
+
+	// allocation failed
+	return NULL;
+}
+
+void	*operator new[](size_t reportedSize)
+{
+	if (reportedSize == 0)
+		reportedSize = 1;
+	void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize);
+	// :TODO: Handler support ?
+	if (ptr)
+		return ptr;
+
+	// allocation failed
+	return NULL;
+}
+
+// Microsoft memory tracking operators
+void	*operator new(size_t reportedSize, const char *sourceFile, int sourceLine)
+{
+	if (reportedSize == 0)
+		reportedSize = 1;
+	void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new, reportedSize);
+	// :TODO: Handler support ?
+	if (ptr)
+		return ptr;
+
+	// allocation failed
+	return NULL;
+}
+void	*operator new[](size_t reportedSize, const char *sourceFile, int sourceLine)
+{
+	if (reportedSize == 0)
+		reportedSize = 1;
+	void *ptr = Mem_Allocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_new_array, reportedSize);
+	// :TODO: Handler support ?
+	if (ptr)
+		return ptr;
+
+	// allocation failed
+	return NULL;
+}
+
+void	operator delete(void *reportedAddress)
+{
+	if (!reportedAddress)
+		return;
+
+	Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete, reportedAddress);
+}
+
+void	operator delete[](void *reportedAddress)
+{
+	if (!reportedAddress)
+		return;
+
+	Mem_Deallocator(g_Mem_CurrentFilename, g_Mem_CurrentLine, g_Mem_CurrentFunc, m_alloc_delete_array, reportedAddress);
+}
+
+/************* stuff from dlls/util.cpp *************/
+//				must come here because cbase.h declares it's own operator new
+
+#ifdef USE_METAMOD
+
+// Selected portions of dlls/util.cpp from SDK 2.1.
+// Functions copied from there as needed...
+// And modified to avoid buffer overflows (argh).
+
+/***
+*
+*	Copyright (c) 1999, 2000 Valve LLC. All rights reserved.
+*	
+*	This product contains software technology licensed from Id 
+*	Software, Inc. ("Id Technology").  Id Technology (c) 1996 Id Software, Inc. 
+*	All Rights Reserved.
+*
+*   Use, distribution, and modification of this source code and/or resulting
+*   object code is restricted to non-commercial enhancements to products from
+*   Valve LLC.  All other use, distribution, or modification is prohibited
+*   without written permission from Valve LLC.
+*
+****/
+/*
+
+===== util.cpp ========================================================
+
+  Utility code.  Really not optional after all.
+
+*/
+
+#include <extdll.h>
+#include "sdk_util.h"
+#include <cbase.h>
+
+#include <string.h>			// for strncpy(), etc
+
+#include "osdep.h"			// win32 vsnprintf, etc
+
+char* UTIL_VarArgs( char *format, ... )
+{
+	va_list		argptr;
+	static char		string[1024];
+	
+	va_start (argptr, format);
+	vsnprintf (string, sizeof(string), format, argptr);
+	va_end (argptr);
+
+	return string;
+}
+	
+
+//=========================================================
+// UTIL_LogPrintf - Prints a logged message to console.
+// Preceded by LOG: ( timestamp ) < message >
+//=========================================================
+void UTIL_LogPrintf( char *fmt, ... )
+{
+	va_list			argptr;
+	static char		string[1024];
+	
+	va_start ( argptr, fmt );
+	vsnprintf ( string, sizeof(string), fmt, argptr );
+	va_end   ( argptr );
+
+	// Print to server console
+	ALERT( at_logged, "%s", string );
+}
+
+
+void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, 
+		const char *pMessage)
+{
+	if ( !pEntity )
+		return;
+
+	MESSAGE_BEGIN( MSG_ONE, SVC_TEMPENTITY, NULL, ENT(pEntity->pev) );
+		WRITE_BYTE( TE_TEXTMESSAGE );
+		WRITE_BYTE( textparms.channel & 0xFF );
+
+		WRITE_SHORT( FixedSigned16( textparms.x, 1<<13 ) );
+		WRITE_SHORT( FixedSigned16( textparms.y, 1<<13 ) );
+		WRITE_BYTE( textparms.effect );
+
+		WRITE_BYTE( textparms.r1 );
+		WRITE_BYTE( textparms.g1 );
+		WRITE_BYTE( textparms.b1 );
+		WRITE_BYTE( textparms.a1 );
+
+		WRITE_BYTE( textparms.r2 );
+		WRITE_BYTE( textparms.g2 );
+		WRITE_BYTE( textparms.b2 );
+		WRITE_BYTE( textparms.a2 );
+
+		WRITE_SHORT( FixedUnsigned16( textparms.fadeinTime, 1<<8 ) );
+		WRITE_SHORT( FixedUnsigned16( textparms.fadeoutTime, 1<<8 ) );
+		WRITE_SHORT( FixedUnsigned16( textparms.holdTime, 1<<8 ) );
+
+		if ( textparms.effect == 2 )
+			WRITE_SHORT( FixedUnsigned16( textparms.fxTime, 1<<8 ) );
+		
+		if ( strlen( pMessage ) < 512 )
+		{
+			WRITE_STRING( pMessage );
+		}
+		else
+		{
+			char tmp[512];
+			strncpy( tmp, pMessage, 511 );
+			tmp[511] = 0;
+			WRITE_STRING( tmp );
+		}
+	MESSAGE_END();
+}
+
+short FixedSigned16( float value, float scale )
+{
+	int output;
+
+	output = (int) (value * scale);
+
+	if ( output > 32767 )
+		output = 32767;
+
+	if ( output < -32768 )
+		output = -32768;
+
+	return (short)output;
+}
+
+unsigned short FixedUnsigned16( float value, float scale )
+{
+	int output;
+
+	output = (int) (value * scale);
+	if ( output < 0 )
+		output = 0;
+	if ( output > 0xFFFF )
+		output = 0xFFFF;
+
+	return (unsigned short)output;
+}
+#endif // USE_METAMOD
diff --git a/dlls/regex/amxxmodule.h b/dlls/regex/amxxmodule.h
new file mode 100755
index 00000000..e0b0e8fa
--- /dev/null
+++ b/dlls/regex/amxxmodule.h
@@ -0,0 +1,2197 @@
+/*
+ * AMX Mod X Module Interface Functions
+ * This file may be freely used
+*/
+
+// prevent double include
+#ifndef __AMXXMODULE_H__
+#define __AMXXMODULE_H__
+
+// config
+#include "moduleconfig.h"
+
+// metamod include files
+#ifdef USE_METAMOD
+#include <extdll.h>
+#include <meta_api.h>
+#include "osdep.h"
+#endif // #ifdef USE_METAMOD
+
+// DLL Export
+#undef DLLEXPORT
+#ifndef __linux__
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#define LINUX
+#endif
+
+#undef C_DLLEXPORT
+#define C_DLLEXPORT extern "C" DLLEXPORT
+
+// ***** AMXX stuff *****
+
+// module interface version is 1
+#define AMXX_INTERFACE_VERSION 1
+
+// amxx module info
+struct amxx_module_info_s
+{
+	const char *name;
+	const char *author;
+	const char *version;
+	int reload;				// reload on mapchange when nonzero
+};
+
+
+
+// return values from functions called by amxx
+#define AMXX_OK					0			/* no error */
+#define AMXX_IFVERS				1			/* interface version */
+#define AMXX_PARAM				2			/* Invalid parameter */
+#define AMXX_FUNC_NOT_PRESENT	3			/* Function not present */
+
+// *** Small stuff ***
+// The next section is copied from the amx.h file
+// Copyright (c) ITB CompuPhase, 1997-2004
+
+#if defined __LCC__ || defined __DMC__ || defined __linux__ || defined __GNUC__
+  #include <stdint.h>
+#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
+  /* The ISO C99 defines the int16_t and int_32t types. If the compiler got
+   * here, these types are probably undefined.
+   */
+  #if defined __FreeBSD__
+    #include <inttypes.h>
+  #else
+    typedef short int           int16_t;
+    typedef unsigned short int  uint16_t;
+    #if defined SN_TARGET_PS2
+      typedef int               int32_t;
+      typedef unsigned int      uint32_t;
+    #else
+      typedef long int          int32_t;
+      typedef unsigned long int uint32_t;
+    #endif
+    #if defined __WIN32__ || defined _WIN32 || defined WIN32
+      typedef __int64			int64_t;
+      typedef unsigned __int64	uint64_t;
+      #define HAVE_I64
+    #elif defined __GNUC__
+      typedef long long			int64_t;
+      typedef unsigned long long uint64_t;
+      #define HAVE_I64
+    #endif
+  #endif
+#endif
+
+
+/* calling convention for native functions */
+#if !defined AMX_NATIVE_CALL
+  #define AMX_NATIVE_CALL
+#endif
+/* calling convention for all interface functions and callback functions */
+#if !defined AMXAPI
+  #if defined STDECL
+    #define AMXAPI      __stdcall
+  #elif defined CDECL
+    #define AMXAPI      __cdecl
+  #else
+    #define AMXAPI
+  #endif
+#endif
+#if !defined AMXEXPORT
+  #define AMXEXPORT
+#endif
+
+
+
+#if !defined SMALL_CELL_SIZE
+  #define SMALL_CELL_SIZE 32    /* by default, use 32-bit cells */
+#endif
+#if SMALL_CELL_SIZE==32
+  typedef uint32_t  ucell;
+  typedef int32_t   cell;
+  typedef float		REAL;
+#elif SMALL_CELL_SIZE==64
+  typedef uint64_t  ucell;
+  typedef int64_t   cell;
+  typedef double	REAL;
+#else
+  #error Unsupported cell size (SMALL_CELL_SIZE)
+#endif
+
+#define UNPACKEDMAX   ((1 << (sizeof(cell)-1)*8) - 1)
+
+struct tagAMX;
+typedef cell (AMX_NATIVE_CALL *AMX_NATIVE)(struct tagAMX *amx, cell *params);
+typedef int (AMXAPI *AMX_CALLBACK)(struct tagAMX *amx, cell index,
+                                   cell *result, cell *params);
+typedef int (AMXAPI *AMX_DEBUG)(struct tagAMX *amx);
+#if !defined _FAR
+  #define _FAR
+#endif
+
+#if defined _MSC_VER
+  #pragma warning(disable:4103)  /* disable warning message 4103 that complains
+                                  * about pragma pack in a header file */
+  #pragma warning(disable:4100)  /* "'%$S' : unreferenced formal parameter" */
+#endif
+
+
+#if defined SN_TARGET_PS2 || defined __GNUC__
+  #define AMX_NO_ALIGN
+#endif
+
+
+#if defined __GNUC__
+  #define PACKED        __attribute__((packed))
+#else
+  #define PACKED
+#endif
+
+
+#if !defined AMX_NO_ALIGN
+  #if defined __linux__
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+  #else
+    #pragma pack(push)
+    #pragma pack(1)         /* structures must be packed (byte-aligned) */
+    #if defined __TURBOC__
+      #pragma option -a-    /* "pack" pragma for older Borland compilers */
+    #endif
+  #endif
+#endif
+
+typedef struct {
+  const char _FAR *name PACKED;
+  AMX_NATIVE func       PACKED;
+} AMX_NATIVE_INFO;
+
+#define AMX_USERNUM     4
+
+/* The AMX structure is the internal structure for many functions. Not all
+ * fields are valid at all times; many fields are cached in local variables.
+ */
+typedef struct tagAMX {
+  unsigned char _FAR *base PACKED; /* points to the AMX header ("amxhdr") plus the code, optionally also the data */
+  unsigned char _FAR *data PACKED; /* points to separate data+stack+heap, may be NULL */
+  AMX_CALLBACK callback PACKED;
+  AMX_DEBUG debug       PACKED; /* debug callback */
+  /* for external functions a few registers must be accessible from the outside */
+  cell cip              PACKED; /* instruction pointer: relative to base + amxhdr->cod */
+  cell frm              PACKED; /* stack frame base: relative to base + amxhdr->dat */
+  cell hea              PACKED; /* top of the heap: relative to base + amxhdr->dat */
+  cell hlw              PACKED; /* bottom of the heap: relative to base + amxhdr->dat */
+  cell stk              PACKED; /* stack pointer: relative to base + amxhdr->dat */
+  cell stp              PACKED; /* top of the stack: relative to base + amxhdr->dat */
+  int flags             PACKED; /* current status, see amx_Flags() */
+  /* for assertions and debug hook */
+  cell curline          PACKED;
+  cell curfile          PACKED;
+  int dbgcode           PACKED;
+  cell dbgaddr          PACKED;
+  cell dbgparam         PACKED;
+  char _FAR *dbgname    PACKED;
+  /* user data */
+  long usertags[AMX_USERNUM] PACKED;
+  void _FAR *userdata[AMX_USERNUM] PACKED;
+  /* native functions can raise an error */
+  int error             PACKED;
+  /* the sleep opcode needs to store the full AMX status */
+  cell pri              PACKED;
+  cell alt              PACKED;
+  cell reset_stk        PACKED;
+  cell reset_hea        PACKED;
+  cell sysreq_d         PACKED; /* relocated address/value for the SYSREQ.D opcode */
+    /* support variables for the JIT */
+    int reloc_size      PACKED; /* required temporary buffer for relocations */
+    long code_size      PACKED; /* estimated memory footprint of the native code */
+} AMX;
+
+enum {
+  AMX_ERR_NONE,
+  /* reserve the first 15 error codes for exit codes of the abstract machine */
+  AMX_ERR_EXIT,         /* forced exit */
+  AMX_ERR_ASSERT,       /* assertion failed */
+  AMX_ERR_STACKERR,     /* stack/heap collision */
+  AMX_ERR_BOUNDS,       /* index out of bounds */
+  AMX_ERR_MEMACCESS,    /* invalid memory access */
+  AMX_ERR_INVINSTR,     /* invalid instruction */
+  AMX_ERR_STACKLOW,     /* stack underflow */
+  AMX_ERR_HEAPLOW,      /* heap underflow */
+  AMX_ERR_CALLBACK,     /* no callback, or invalid callback */
+  AMX_ERR_NATIVE,       /* native function failed */
+  AMX_ERR_DIVIDE,       /* divide by zero */
+  AMX_ERR_SLEEP,        /* go into sleepmode - code can be restarted */
+
+  AMX_ERR_MEMORY = 16,  /* out of memory */
+  AMX_ERR_FORMAT,       /* invalid file format */
+  AMX_ERR_VERSION,      /* file is for a newer version of the AMX */
+  AMX_ERR_NOTFOUND,     /* function not found */
+  AMX_ERR_INDEX,        /* invalid index parameter (bad entry point) */
+  AMX_ERR_DEBUG,        /* debugger cannot run */
+  AMX_ERR_INIT,         /* AMX not initialized (or doubly initialized) */
+  AMX_ERR_USERDATA,     /* unable to set user data field (table full) */
+  AMX_ERR_INIT_JIT,     /* cannot initialize the JIT */
+  AMX_ERR_PARAMS,       /* parameter error */
+  AMX_ERR_DOMAIN,       /* domain error, expression result does not fit in range */
+};
+
+#if !defined AMX_NO_ALIGN
+  #if defined __linux__
+    #pragma pack()    /* reset default packing */
+  #else
+    #pragma pack(pop) /* reset previous packing */
+  #endif
+#endif
+
+
+// ***** declare functions *****
+
+#ifdef USE_METAMOD
+void UTIL_LogPrintf( char *fmt, ... );
+void UTIL_HudMessage(CBaseEntity *pEntity, const hudtextparms_t &textparms, const char *pMessage);
+short FixedSigned16( float value, float scale );
+unsigned short FixedUnsigned16( float value, float scale );
+
+#ifdef FN_META_QUERY
+void FN_META_QUERY(void);
+#endif // FN_META_QUERY
+
+#ifdef FN_META_ATTACH
+void FN_META_ATTACH(void);
+#endif // FN_META_ATTACH
+
+#ifdef FN_META_DETACH
+void FN_META_DETACH(void);
+#endif // FN_META_DETACH
+
+
+
+
+
+#ifdef FN_GameDLLInit
+void FN_GameDLLInit(void);
+#endif // FN_GameDLLInit
+
+#ifdef FN_DispatchSpawn
+int FN_DispatchSpawn(edict_t *pent);
+#endif // FN_DispatchSpawn
+
+#ifdef FN_DispatchThink
+void FN_DispatchThink(edict_t *pent);
+#endif // FN_DispatchThink
+
+#ifdef FN_DispatchUse
+void FN_DispatchUse(edict_t *pentUser, edict_t *pentOther);
+#endif // FN_DispatchUse
+
+#ifdef FN_DispatchTouch
+void FN_DispatchTouch(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_DispatchTouch
+
+#ifdef FN_DispatchBlocked
+void FN_DispatchBlocked(edict_t *pentBlocked, edict_t *pentOther);
+#endif // FN_DispatchBlocked
+
+#ifdef FN_DispatchKeyValue
+void FN_DispatchKeyValue(edict_t *pentKeyvalue, KeyValueData *pkvd);
+#endif // FN_DispatchKeyValue
+
+#ifdef FN_DispatchSave
+void FN_DispatchSave(edict_t *pent, SAVERESTOREDATA *pSaveData);
+#endif // FN_DispatchSave
+
+#ifdef FN_DispatchRestore
+int FN_DispatchRestore(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity);
+#endif // FN_DispatchRestore
+
+#ifdef FN_DispatchObjectCollsionBox
+void FN_DispatchObjectCollsionBox(edict_t *pent);
+#endif // FN_DispatchObjectCollsionBox
+
+#ifdef FN_SaveWriteFields
+void FN_SaveWriteFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveWriteFields
+
+#ifdef FN_SaveReadFields
+void FN_SaveReadFields(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveReadFields
+
+#ifdef FN_SaveGlobalState
+void FN_SaveGlobalState(SAVERESTOREDATA *pSaveData);
+#endif // FN_SaveGlobalState
+
+#ifdef FN_RestoreGlobalState
+void FN_RestoreGlobalState(SAVERESTOREDATA *pSaveData);
+#endif // FN_RestoreGlobalState
+
+#ifdef FN_ResetGlobalState
+void FN_ResetGlobalState(void);
+#endif // FN_ResetGlobalState
+
+#ifdef FN_ClientConnect
+BOOL FN_ClientConnect(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]);
+#endif // FN_ClientConnect
+
+#ifdef FN_ClientDisconnect
+void FN_ClientDisconnect(edict_t *pEntity);
+#endif // FN_ClientDisconnect
+
+#ifdef FN_ClientKill
+void FN_ClientKill(edict_t *pEntity);
+#endif // FN_ClientKill
+
+#ifdef FN_ClientPutInServer
+void FN_ClientPutInServer(edict_t *pEntity);
+#endif // FN_ClientPutInServer
+
+#ifdef FN_ClientCommand
+void FN_ClientCommand(edict_t *pEntity);
+#endif // FN_ClientCommand
+
+#ifdef FN_ClientUserInfoChanged
+void FN_ClientUserInfoChanged(edict_t *pEntity, char *infobuffer);
+#endif // FN_ClientUserInfoChanged
+
+#ifdef FN_ServerActivate
+void FN_ServerActivate(edict_t *pEdictList, int edictCount, int clientMax);
+#endif // FN_ServerActivate
+
+#ifdef FN_ServerDeactivate
+void FN_ServerDeactivate(void);
+#endif // FN_ServerDeactivate
+
+#ifdef FN_PlayerPreThink
+void FN_PlayerPreThink(edict_t *pEntity);
+#endif // FN_PlayerPreThink
+
+#ifdef FN_PlayerPostThink
+void FN_PlayerPostThink(edict_t *pEntity);
+#endif // FN_PlayerPostThink
+
+#ifdef FN_StartFrame
+void FN_StartFrame(void);
+#endif // FN_StartFrame
+
+#ifdef FN_ParmsNewLevel
+void FN_ParmsNewLevel(void);
+#endif // FN_ParmsNewLevel
+
+#ifdef FN_ParmsChangeLevel
+void FN_ParmsChangeLevel(void);
+#endif // FN_ParmsChangeLevel
+
+#ifdef FN_GetGameDescription
+const char *FN_GetGameDescription(void);
+#endif // FN_GetGameDescription
+
+#ifdef FN_PlayerCustomization
+void FN_PlayerCustomization(edict_t *pEntity, customization_t *pCust);
+#endif // FN_PlayerCustomization
+
+#ifdef FN_SpectatorConnect
+void FN_SpectatorConnect(edict_t *pEntity);
+#endif // FN_SpectatorConnect
+
+#ifdef FN_SpectatorDisconnect
+void FN_SpectatorDisconnect(edict_t *pEntity);
+#endif // FN_SpectatorDisconnect
+
+#ifdef FN_SpectatorThink
+void FN_SpectatorThink(edict_t *pEntity);
+#endif // FN_SpectatorThink
+
+#ifdef FN_Sys_Error
+void FN_Sys_Error(const char *error_string);
+#endif // FN_Sys_Error
+
+#ifdef FN_PM_Move
+void FN_PM_Move(struct playermove_s *ppmove, int server);
+#endif // FN_PM_Move
+
+#ifdef FN_PM_Init
+void FN_PM_Init(struct playermove_s *ppmove);
+#endif // FN_PM_Init
+
+#ifdef FN_PM_FindTextureType
+char FN_PM_FindTextureType(char *name);
+#endif // FN_PM_FindTextureType
+
+#ifdef FN_SetupVisibility
+void FN_SetupVisibility(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas);
+#endif // FN_SetupVisibility
+
+#ifdef FN_UpdateClientData
+void FN_UpdateClientData(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd);
+#endif // FN_UpdateClientData
+
+#ifdef FN_AddToFullPack
+int FN_AddToFullPack(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet);
+#endif // FN_AddToFullPack
+
+#ifdef FN_CreateBaseline
+void FN_CreateBaseline(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs);
+#endif // FN_CreateBaseline
+
+#ifdef FN_RegisterEncoders
+void FN_RegisterEncoders(void);
+#endif // FN_RegisterEncoders
+
+#ifdef FN_GetWeaponData
+int FN_GetWeaponData(struct edict_s *player, struct weapon_data_s *info);
+#endif // FN_GetWeaponData
+
+#ifdef FN_CmdStart
+void FN_CmdStart(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed);
+#endif // FN_CmdStart
+
+#ifdef FN_CmdEnd
+void FN_CmdEnd(const edict_t *player);
+#endif // FN_CmdEnd
+
+#ifdef FN_ConnectionlessPacket
+int FN_ConnectionlessPacket(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size);
+#endif // FN_ConnectionlessPacket
+
+#ifdef FN_GetHullBounds
+int FN_GetHullBounds(int hullnumber, float *mins, float *maxs);
+#endif // FN_GetHullBounds
+
+#ifdef FN_CreateInstancedBaselines
+void FN_CreateInstancedBaselines(void);
+#endif // FN_CreateInstancedBaselines
+
+#ifdef FN_InconsistentFile
+int FN_InconsistentFile(const edict_t *player, const char *filename, char *disconnect_message);
+#endif // FN_InconsistentFile
+
+#ifdef FN_AllowLagCompensation
+int FN_AllowLagCompensation(void);
+#endif // FN_AllowLagCompensation
+
+
+
+
+#ifdef FN_GameDLLInit_Post
+void FN_GameDLLInit_Post(void);
+#endif // FN_GameDLLInit_Post
+
+#ifdef FN_DispatchSpawn_Post
+int FN_DispatchSpawn_Post(edict_t *pent);
+#endif // FN_DispatchSpawn_Post
+
+#ifdef FN_DispatchThink_Post
+void FN_DispatchThink_Post(edict_t *pent);
+#endif // FN_DispatchThink_Post
+
+#ifdef FN_DispatchUse_Post
+void FN_DispatchUse_Post(edict_t *pentUser, edict_t *pentOther);
+#endif // FN_DispatchUse_Post
+
+#ifdef FN_DispatchTouch_Post
+void FN_DispatchTouch_Post(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_DispatchTouch_Post
+
+#ifdef FN_DispatchBlocked_Post
+void FN_DispatchBlocked_Post(edict_t *pentBlocked, edict_t *pentOther);
+#endif // FN_DispatchBlocked_Post
+
+#ifdef FN_DispatchKeyValue_Post
+void FN_DispatchKeyValue_Post(edict_t *pentKeyvalue, KeyValueData *pkvd);
+#endif // FN_DispatchKeyValue_Post
+
+#ifdef FN_DispatchSave_Post
+void FN_DispatchSave_Post(edict_t *pent, SAVERESTOREDATA *pSaveData);
+#endif // FN_DispatchSave_Post
+
+#ifdef FN_DispatchRestore_Post
+int FN_DispatchRestore_Post(edict_t *pent, SAVERESTOREDATA *pSaveData, int globalEntity);
+#endif // FN_DispatchRestore_Post
+
+#ifdef FN_DispatchObjectCollsionBox_Post
+void FN_DispatchObjectCollsionBox_Post(edict_t *pent);
+#endif // FN_DispatchObjectCollsionBox_Post
+
+#ifdef FN_SaveWriteFields_Post
+void FN_SaveWriteFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveWriteFields_Post
+
+#ifdef FN_SaveReadFields_Post
+void FN_SaveReadFields_Post(SAVERESTOREDATA *pSaveData, const char *pname, void *pBaseData, TYPEDESCRIPTION *pFields, int fieldCount);
+#endif // FN_SaveReadFields_Post
+
+#ifdef FN_SaveGlobalState_Post
+void FN_SaveGlobalState_Post(SAVERESTOREDATA *pSaveData);
+#endif // FN_SaveGlobalState_Post
+
+#ifdef FN_RestoreGlobalState_Post
+void FN_RestoreGlobalState_Post(SAVERESTOREDATA *pSaveData);
+#endif // FN_RestoreGlobalState_Post
+
+#ifdef FN_ResetGlobalState_Post
+void FN_ResetGlobalState_Post(void);
+#endif // FN_ResetGlobalState_Post
+
+#ifdef FN_ClientConnect_Post
+BOOL FN_ClientConnect_Post(edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]);
+#endif // FN_ClientConnect_Post
+
+#ifdef FN_ClientDisconnect_Post
+void FN_ClientDisconnect_Post(edict_t *pEntity);
+#endif // FN_ClientDisconnect_Post
+
+#ifdef FN_ClientKill_Post
+void FN_ClientKill_Post(edict_t *pEntity);
+#endif // FN_ClientKill_Post
+
+#ifdef FN_ClientPutInServer_Post
+void FN_ClientPutInServer_Post(edict_t *pEntity);
+#endif // FN_ClientPutInServer_Post
+
+#ifdef FN_ClientCommand_Post
+void FN_ClientCommand_Post(edict_t *pEntity);
+#endif // FN_ClientCommand_Post
+
+#ifdef FN_ClientUserInfoChanged_Post
+void FN_ClientUserInfoChanged_Post(edict_t *pEntity, char *infobuffer);
+#endif // FN_ClientUserInfoChanged_Post
+
+#ifdef FN_ServerActivate_Post
+void FN_ServerActivate_Post(edict_t *pEdictList, int edictCount, int clientMax);
+#endif // FN_ServerActivate_Post
+
+#ifdef FN_ServerDeactivate_Post
+void FN_ServerDeactivate_Post(void);
+#endif // FN_ServerDeactivate_Post
+
+#ifdef FN_PlayerPreThink_Post
+void FN_PlayerPreThink_Post(edict_t *pEntity);
+#endif // FN_PlayerPreThink_Post
+
+#ifdef FN_PlayerPostThink_Post
+void FN_PlayerPostThink_Post(edict_t *pEntity);
+#endif // FN_PlayerPostThink_Post
+
+#ifdef FN_StartFrame_Post
+void FN_StartFrame_Post(void);
+#endif // FN_StartFrame_Post
+
+#ifdef FN_ParmsNewLevel_Post
+void FN_ParmsNewLevel_Post(void);
+#endif // FN_ParmsNewLevel_Post
+
+#ifdef FN_ParmsChangeLevel_Post
+void FN_ParmsChangeLevel_Post(void);
+#endif // FN_ParmsChangeLevel_Post
+
+#ifdef FN_GetGameDescription_Post
+const char *FN_GetGameDescription_Post(void);
+#endif // FN_GetGameDescription_Post
+
+#ifdef FN_PlayerCustomization_Post
+void FN_PlayerCustomization_Post(edict_t *pEntity, customization_t *pCust);
+#endif // FN_PlayerCustomization_Post
+
+#ifdef FN_SpectatorConnect_Post
+void FN_SpectatorConnect_Post(edict_t *pEntity);
+#endif // FN_SpectatorConnect_Post
+
+#ifdef FN_SpectatorDisconnect_Post
+void FN_SpectatorDisconnect_Post(edict_t *pEntity);
+#endif // FN_SpectatorDisconnect_Post
+
+#ifdef FN_SpectatorThink_Post
+void FN_SpectatorThink_Post(edict_t *pEntity);
+#endif // FN_SpectatorThink_Post
+
+#ifdef FN_Sys_Error_Post
+void FN_Sys_Error_Post(const char *error_string);
+#endif // FN_Sys_Error_Post
+
+#ifdef FN_PM_Move_Post
+void FN_PM_Move_Post(struct playermove_s *ppmove, int server);
+#endif // FN_PM_Move_Post
+
+#ifdef FN_PM_Init_Post
+void FN_PM_Init_Post(struct playermove_s *ppmove);
+#endif // FN_PM_Init_Post
+
+#ifdef FN_PM_FindTextureType_Post
+char FN_PM_FindTextureType_Post(char *name);
+#endif // FN_PM_FindTextureType_Post
+
+#ifdef FN_SetupVisibility_Post
+void FN_SetupVisibility_Post(edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas);
+#endif // FN_SetupVisibility_Post
+
+#ifdef FN_UpdateClientData_Post
+void FN_UpdateClientData_Post(const struct edict_s *ent, int sendweapons, struct clientdata_s *cd);
+#endif // FN_UpdateClientData_Post
+
+#ifdef FN_AddToFullPack_Post
+int FN_AddToFullPack_Post(struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet);
+#endif // FN_AddToFullPack_Post
+
+#ifdef FN_CreateBaseline_Post
+void FN_CreateBaseline_Post(int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs);
+#endif // FN_CreateBaseline_Post
+
+#ifdef FN_RegisterEncoders_Post
+void FN_RegisterEncoders_Post(void);
+#endif // FN_RegisterEncoders_Post
+
+#ifdef FN_GetWeaponData_Post
+int FN_GetWeaponData_Post(struct edict_s *player, struct weapon_data_s *info);
+#endif // FN_GetWeaponData_Post
+
+#ifdef FN_CmdStart_Post
+void FN_CmdStart_Post(const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed);
+#endif // FN_CmdStart_Post
+
+#ifdef FN_CmdEnd_Post
+void FN_CmdEnd_Post(const edict_t *player);
+#endif // FN_CmdEnd_Post
+
+#ifdef FN_ConnectionlessPacket_Post
+int FN_ConnectionlessPacket_Post(const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size);
+#endif // FN_ConnectionlessPacket_Post
+
+#ifdef FN_GetHullBounds_Post
+int FN_GetHullBounds_Post(int hullnumber, float *mins, float *maxs);
+#endif // FN_GetHullBounds_Post
+
+#ifdef FN_CreateInstancedBaselines_Post
+void FN_CreateInstancedBaselines_Post(void);
+#endif // FN_CreateInstancedBaselines_Post
+
+#ifdef FN_InconsistentFile_Post
+int FN_InconsistentFile_Post(const edict_t *player, const char *filename, char *disconnect_message);
+#endif // FN_InconsistentFile_Post
+
+#ifdef FN_AllowLagCompensation_Post
+int FN_AllowLagCompensation_Post(void);
+#endif // FN_AllowLagCompensation_Post
+
+
+
+#ifdef FN_PrecacheModel
+int FN_PrecacheModel(char *s);
+#endif // FN_PrecacheModel
+
+#ifdef FN_PrecacheSound
+int FN_PrecacheSound(char *s);
+#endif // FN_PrecacheSound
+
+#ifdef FN_SetModel
+void FN_SetModel(edict_t *e, const char *m);
+#endif // FN_SetModel
+
+#ifdef FN_ModelIndex
+int FN_ModelIndex(const char *m);
+#endif // FN_ModelIndex
+
+#ifdef FN_ModelFrames
+int FN_ModelFrames(int modelIndex);
+#endif // FN_ModelFrames
+
+#ifdef FN_SetSize
+void FN_SetSize(edict_t *e, const float *rgflMin, const float *rgflMax);
+#endif // FN_SetSize
+
+#ifdef FN_ChangeLevel
+void FN_ChangeLevel(char *s1, char *s2);
+#endif // FN_ChangeLevel
+
+#ifdef FN_GetSpawnParms
+void FN_GetSpawnParms(edict_t *ent);
+#endif // FN_GetSpawnParms
+
+#ifdef FN_SaveSpawnParms
+void FN_SaveSpawnParms(edict_t *ent);
+#endif // FN_SaveSpawnParms
+
+#ifdef FN_VecToYaw
+float FN_VecToYaw(const float *rgflVector);
+#endif // FN_VecToYaw
+
+#ifdef FN_VecToAngles
+void FN_VecToAngles(const float *rgflVectorIn, float *rgflVectorOut);
+#endif // FN_VecToAngles
+
+#ifdef FN_MoveToOrigin
+void FN_MoveToOrigin(edict_t *ent, const float *pflGoal, float dist, int iMoveType);
+#endif // FN_MoveToOrigin
+
+#ifdef FN_ChangeYaw
+void FN_ChangeYaw(edict_t *ent);
+#endif // FN_ChangeYaw
+
+#ifdef FN_ChangePitch
+void FN_ChangePitch(edict_t *ent);
+#endif // FN_ChangePitch
+
+#ifdef FN_FindEntityByString
+edict_t *FN_FindEntityByString(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue);
+#endif // FN_FindEntityByString
+
+#ifdef FN_GetEntityIllum
+int FN_GetEntityIllum(edict_t *pEnt);
+#endif // FN_GetEntityIllum
+
+#ifdef FN_FindEntityInSphere
+edict_t *FN_FindEntityInSphere(edict_t *pEdictStartSearchAfter, const float *org, float rad);
+#endif // FN_FindEntityInSphere
+
+#ifdef FN_FindClientInPVS
+edict_t *FN_FindClientInPVS(edict_t *pEdict);
+#endif // FN_FindClientInPVS
+
+#ifdef FN_EntitiesInPVS
+edict_t *FN_EntitiesInPVS(edict_t *pplayer);
+#endif // FN_EntitiesInPVS
+
+#ifdef FN_MakeVectors
+void FN_MakeVectors(const float *rgflVector);
+#endif // FN_MakeVectors
+
+#ifdef FN_AngleVectors
+void FN_AngleVectors(const float *rgflVector, float *forward, float *right, float *up);
+#endif // FN_AngleVectors
+
+#ifdef FN_CreateEntity
+edict_t *FN_CreateEntity(void);
+#endif // FN_CreateEntity
+
+#ifdef FN_RemoveEntity
+void FN_RemoveEntity(edict_t *e);
+#endif // FN_RemoveEntity
+
+#ifdef FN_CreateNamedEntity
+edict_t *FN_CreateNamedEntity(int className);
+#endif // FN_CreateNamedEntity
+
+#ifdef FN_MakeStatic
+void FN_MakeStatic(edict_t *ent);
+#endif // FN_MakeStatic
+
+#ifdef FN_EntIsOnFloor
+int FN_EntIsOnFloor(edict_t *ent);
+#endif // FN_EntIsOnFloor
+
+#ifdef FN_DropToFloor
+int FN_DropToFloor(edict_t *ent);
+#endif // FN_DropToFloor
+
+#ifdef FN_WalkMove
+int FN_WalkMove(edict_t *ent, float yaw, float dist, int iMode);
+#endif // FN_WalkMove
+
+#ifdef FN_SetOrigin
+void FN_SetOrigin(edict_t *e, const float *rgflOrigin);
+#endif // FN_SetOrigin
+
+#ifdef FN_EmitSound
+void FN_EmitSound(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitSound
+
+#ifdef FN_EmitAmbientSound
+void FN_EmitAmbientSound(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitAmbientSound
+
+#ifdef FN_TraceLine
+void FN_TraceLine(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceLine
+
+#ifdef FN_TraceToss
+void FN_TraceToss(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr);
+#endif // FN_TraceToss
+
+#ifdef FN_TraceMonsterHull
+int FN_TraceMonsterHull(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceMonsterHull
+
+#ifdef FN_TraceHull
+void FN_TraceHull(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceHull
+
+#ifdef FN_TraceModel
+void FN_TraceModel(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr);
+#endif // FN_TraceModel
+
+#ifdef FN_TraceTexture
+const char *FN_TraceTexture(edict_t *pTextureEntity, const float *v1, const float *v2 );
+#endif // FN_TraceTexture
+
+#ifdef FN_TraceSphere
+void FN_TraceSphere(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceSphere
+
+#ifdef FN_GetAimVector
+void FN_GetAimVector(edict_t *ent, float speed, float *rgflReturn);
+#endif // FN_GetAimVector
+
+#ifdef FN_ServerCommand
+void FN_ServerCommand(char *str);
+#endif // FN_ServerCommand
+
+#ifdef FN_ServerExecute
+void FN_ServerExecute(void);
+#endif // FN_ServerExecute
+
+#ifdef FN_engClientCommand
+void FN_engClientCommand(edict_t *pEdict, char *szFmt, ...);
+#endif // FN_engClientCommand
+
+#ifdef FN_ParticleEffect
+void FN_ParticleEffect(const float *org, const float *dir, float color, float count);
+#endif // FN_ParticleEffect
+
+#ifdef FN_LightStyle
+void FN_LightStyle(int style, char *val);
+#endif // FN_LightStyle
+
+#ifdef FN_DecalIndex
+int FN_DecalIndex(const char *name);
+#endif // FN_DecalIndex
+
+#ifdef FN_PointContents
+int FN_PointContents(const float *rgflVector);
+#endif // FN_PointContents
+
+#ifdef FN_MessageBegin
+void FN_MessageBegin(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_MessageBegin
+
+#ifdef FN_MessageEnd
+void FN_MessageEnd(void);
+#endif // FN_MessageEnd
+
+#ifdef FN_WriteByte
+void FN_WriteByte(int iValue);
+#endif // FN_WriteByte
+
+#ifdef FN_WriteChar
+void FN_WriteChar(int iValue);
+#endif // FN_WriteChar
+
+#ifdef FN_WriteShort
+void FN_WriteShort(int iValue);
+#endif // FN_WriteShort
+
+#ifdef FN_WriteLong
+void FN_WriteLong(int iValue);
+#endif // FN_WriteLong
+
+#ifdef FN_WriteAngle
+void FN_WriteAngle(float flValue);
+#endif // FN_WriteAngle
+
+#ifdef FN_WriteCoord
+void FN_WriteCoord(float flValue);
+#endif // FN_WriteCoord
+
+#ifdef FN_WriteString
+void FN_WriteString(const char *sz);
+#endif // FN_WriteString
+
+#ifdef FN_WriteEntity
+void FN_WriteEntity(int iValue);
+#endif // FN_WriteEntity
+
+#ifdef FN_CVarRegister
+void FN_CVarRegister(cvar_t *pCvar);
+#endif // FN_CVarRegister
+
+#ifdef FN_CVarGetFloat
+float FN_CVarGetFloat(const char *szVarName);
+#endif // FN_CVarGetFloat
+
+#ifdef FN_CVarGetString
+const char *FN_CVarGetString(const char *szVarName);
+#endif // FN_CVarGetString
+
+#ifdef FN_CVarSetFloat
+void FN_CVarSetFloat(const char *szVarName, float flValue);
+#endif // FN_CVarSetFloat
+
+#ifdef FN_CVarSetString
+void FN_CVarSetString(const char *szVarName, const char *szValue);
+#endif // FN_CVarSetString
+
+#ifdef FN_AlertMessage
+void FN_AlertMessage(ALERT_TYPE atype, char *szFmt, ...);
+#endif // FN_AlertMessage
+
+#ifdef FN_EngineFprintf
+void FN_EngineFprintf(FILE *pfile, char *szFmt, ...);
+#endif // FN_EngineFprintf
+
+#ifdef FN_PvAllocEntPrivateData
+void *FN_PvAllocEntPrivateData(edict_t *pEdict, int32 cb);
+#endif // FN_PvAllocEntPrivateData
+
+#ifdef FN_PvEntPrivateData
+void *FN_PvEntPrivateData(edict_t *pEdict);
+#endif // FN_PvEntPrivateData
+
+#ifdef FN_FreeEntPrivateData
+void FN_FreeEntPrivateData(edict_t *pEdict);
+#endif // FN_FreeEntPrivateData
+
+#ifdef FN_SzFromIndex
+const char *FN_SzFromIndex(int iString);
+#endif // FN_SzFromIndex
+
+#ifdef FN_AllocString
+int FN_AllocString(const char *szValue);
+#endif // FN_AllocString
+
+#ifdef FN_GetVarsOfEnt
+struct entvars_s *FN_GetVarsOfEnt(edict_t *pEdict);
+#endif // FN_GetVarsOfEnt
+
+#ifdef FN_PEntityOfEntOffset
+edict_t *FN_PEntityOfEntOffset(int iEntOffset);
+#endif // FN_PEntityOfEntOffset
+
+#ifdef FN_EntOffsetOfPEntity
+int FN_EntOffsetOfPEntity(const edict_t *pEdict);
+#endif // FN_EntOffsetOfPEntity
+
+#ifdef FN_IndexOfEdict
+int FN_IndexOfEdict(const edict_t *pEdict);
+#endif // FN_IndexOfEdict
+
+#ifdef FN_PEntityOfEntIndex
+edict_t *FN_PEntityOfEntIndex(int iEntIndex);
+#endif // FN_PEntityOfEntIndex
+
+#ifdef FN_FindEntityByVars
+edict_t *FN_FindEntityByVars(struct entvars_s *pvars);
+#endif // FN_FindEntityByVars
+
+#ifdef FN_GetModelPtr
+void *FN_GetModelPtr(edict_t *pEdict);
+#endif // FN_GetModelPtr
+
+#ifdef FN_RegUserMsg
+int FN_RegUserMsg(const char *pszName, int iSize);
+#endif // FN_RegUserMsg
+
+#ifdef FN_AnimationAutomove
+void FN_AnimationAutomove(const edict_t *pEdict, float flTime);
+#endif // FN_AnimationAutomove
+
+#ifdef FN_GetBonePosition
+void FN_GetBonePosition(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles);
+#endif // FN_GetBonePosition
+
+#ifdef FN_FunctionFromName
+unsigned long FN_FunctionFromName(const char *pName);
+#endif // FN_FunctionFromName
+
+#ifdef FN_NameForFunction
+const char *FN_NameForFunction(unsigned long function);
+#endif // FN_NameForFunction
+
+#ifdef FN_ClientPrintf
+void FN_ClientPrintf(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg);
+#endif // FN_ClientPrintf
+
+#ifdef FN_ServerPrint
+void FN_ServerPrint(const char *szMsg);
+#endif // FN_ServerPrint
+
+#ifdef FN_Cmd_Args
+const char *FN_Cmd_Args(void);
+#endif // FN_Cmd_Args
+
+#ifdef FN_Cmd_Argv
+const char *FN_Cmd_Argv(int argc);
+#endif // FN_Cmd_Argv
+
+#ifdef FN_Cmd_Argc
+int FN_Cmd_Argc(void);
+#endif // FN_Cmd_Argc
+
+#ifdef FN_GetAttachment
+void FN_GetAttachment(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles );
+#endif // FN_GetAttachment
+
+#ifdef FN_CRC32_Init
+void FN_CRC32_Init(CRC32_t *pulCRC);
+#endif // FN_CRC32_Init
+
+#ifdef FN_CRC32_ProcessBuffer
+void FN_CRC32_ProcessBuffer(CRC32_t *pulCRC, void *p, int len);
+#endif // FN_CRC32_ProcessBuffer
+
+#ifdef FN_CRC32_ProcessByte
+void FN_CRC32_ProcessByte(CRC32_t *pulCRC, unsigned char ch);
+#endif // FN_CRC32_ProcessByte
+
+#ifdef FN_CRC32_Final
+CRC32_t FN_CRC32_Final(CRC32_t pulCRC);
+#endif // FN_CRC32_Final
+
+#ifdef FN_RandomLong
+long FN_RandomLong(long lLow, long lHigh);
+#endif // FN_RandomLong
+
+#ifdef FN_RandomFloat
+float FN_RandomFloat(float flLow, float flHigh);
+#endif // FN_RandomFloat
+
+#ifdef FN_SetView
+void FN_SetView(const edict_t *pClient, const edict_t *pViewent);
+#endif // FN_SetView
+
+#ifdef FN_Time
+float FN_Time(void);
+#endif // FN_Time
+
+#ifdef FN_CrosshairAngle
+void FN_CrosshairAngle(const edict_t *pClient, float pitch, float yaw);
+#endif // FN_CrosshairAngle
+
+#ifdef FN_LoadFileForMe
+byte *FN_LoadFileForMe(char *filename, int *pLength);
+#endif // FN_LoadFileForMe
+
+#ifdef FN_FreeFile
+void FN_FreeFile(void *buffer);
+#endif // FN_FreeFile
+
+#ifdef FN_EndSection
+void FN_EndSection(const char *pszSectionName);
+#endif // FN_EndSection
+
+#ifdef FN_CompareFileTime
+int FN_CompareFileTime(char *filename1, char *filename2, int *iCompare);
+#endif // FN_CompareFileTime
+
+#ifdef FN_GetGameDir
+void FN_GetGameDir(char *szGetGameDir);
+#endif // FN_GetGameDir
+
+#ifdef FN_Cvar_RegisterVariable
+void FN_Cvar_RegisterVariable(cvar_t *variable);
+#endif // FN_Cvar_RegisterVariable
+
+#ifdef FN_FadeClientVolume
+void FN_FadeClientVolume(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds);
+#endif // FN_FadeClientVolume
+
+#ifdef FN_SetClientMaxspeed
+void FN_SetClientMaxspeed(const edict_t *pEdict, float fNewMaxspeed);
+#endif // FN_SetClientMaxspeed
+
+#ifdef FN_CreateFakeClient
+edict_t *FN_CreateFakeClient(const char *netname);
+#endif // FN_CreateFakeClient
+
+#ifdef FN_RunPlayerMove
+void FN_RunPlayerMove(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec);
+#endif // FN_RunPlayerMove
+
+#ifdef FN_NumberOfEntities
+int FN_NumberOfEntities(void);
+#endif // FN_NumberOfEntities
+
+#ifdef FN_GetInfoKeyBuffer
+char *FN_GetInfoKeyBuffer(edict_t *e);
+#endif // FN_GetInfoKeyBuffer
+
+#ifdef FN_InfoKeyValue
+char *FN_InfoKeyValue(char *infobuffer, char *key);
+#endif // FN_InfoKeyValue
+
+#ifdef FN_SetKeyValue
+void FN_SetKeyValue(char *infobuffer, char *key, char *value);
+#endif // FN_SetKeyValue
+
+#ifdef FN_SetClientKeyValue
+void FN_SetClientKeyValue(int clientIndex, char *infobuffer, char *key, char *value);
+#endif // FN_SetClientKeyValue
+
+#ifdef FN_IsMapValid
+int FN_IsMapValid(char *filename);
+#endif // FN_IsMapValid
+
+#ifdef FN_StaticDecal
+void FN_StaticDecal(const float *origin, int decalIndex, int entityIndex, int modelIndex);
+#endif // FN_StaticDecal
+
+#ifdef FN_PrecacheGeneric
+int FN_PrecacheGeneric(char *s);
+#endif // FN_PrecacheGeneric
+
+#ifdef FN_GetPlayerUserId
+int FN_GetPlayerUserId(edict_t *e );
+#endif // FN_GetPlayerUserId
+
+#ifdef FN_BuildSoundMsg
+void FN_BuildSoundMsg(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_BuildSoundMsg
+
+#ifdef FN_IsDedicatedServer
+int FN_IsDedicatedServer(void);
+#endif // FN_IsDedicatedServer
+
+#ifdef FN_CVarGetPointer
+cvar_t *FN_CVarGetPointer(const char *szVarName);
+#endif // FN_CVarGetPointer
+
+#ifdef FN_GetPlayerWONId
+unsigned int FN_GetPlayerWONId(edict_t *e);
+#endif // FN_GetPlayerWONId
+
+#ifdef FN_Info_RemoveKey
+void FN_Info_RemoveKey( char *s, const char *key);
+#endif // FN_Info_RemoveKey
+
+#ifdef FN_GetPhysicsKeyValue
+const char *FN_GetPhysicsKeyValue(const edict_t *pClient, const char *key);
+#endif // FN_GetPhysicsKeyValue
+
+#ifdef FN_SetPhysicsKeyValue
+void FN_SetPhysicsKeyValue(const edict_t *pClient, const char *key, const char *value);
+#endif // FN_SetPhysicsKeyValue
+
+#ifdef FN_GetPhysicsInfoString
+const char *FN_GetPhysicsInfoString( const edict_t *pClient);
+#endif // FN_GetPhysicsInfoString
+
+#ifdef FN_PrecacheEvent
+unsigned short FN_PrecacheEvent(int type, const char *psz);
+#endif // FN_PrecacheEvent
+
+#ifdef FN_PlaybackEvent
+void FN_PlaybackEvent(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2);
+#endif // FN_PlaybackEvent
+
+#ifdef FN_SetFatPVS
+unsigned char *FN_SetFatPVS(float *org);
+#endif // FN_SetFatPVS
+
+#ifdef FN_SetFatPAS
+unsigned char *FN_SetFatPAS(float *org);
+#endif // FN_SetFatPAS
+
+#ifdef FN_CheckVisibility
+int FN_CheckVisibility(const edict_t *entity, unsigned char *pset);
+#endif // FN_CheckVisibility
+
+#ifdef FN_DeltaSetField
+void FN_DeltaSetField(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaSetField
+
+#ifdef FN_DeltaUnsetField
+void FN_DeltaUnsetField(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaUnsetField
+
+#ifdef FN_DeltaAddEncoder
+void FN_DeltaAddEncoder(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) );
+#endif // FN_DeltaAddEncoder
+
+#ifdef FN_GetCurrentPlayer
+int FN_GetCurrentPlayer(void);
+#endif // FN_GetCurrentPlayer
+
+#ifdef FN_CanSkipPlayer
+int FN_CanSkipPlayer(const edict_t *player);
+#endif // FN_CanSkipPlayer
+
+#ifdef FN_DeltaFindField
+int FN_DeltaFindField(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaFindField
+
+#ifdef FN_DeltaSetFieldByIndex
+void FN_DeltaSetFieldByIndex(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaSetFieldByIndex
+
+#ifdef FN_DeltaUnsetFieldByIndex
+void FN_DeltaUnsetFieldByIndex(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaUnsetFieldByIndex
+
+#ifdef FN_SetGroupMask
+void FN_SetGroupMask(int mask, int op);
+#endif // FN_SetGroupMask
+
+#ifdef FN_engCreateInstancedBaseline
+int FN_engCreateInstancedBaseline(int classname, struct entity_state_s *baseline);
+#endif // FN_engCreateInstancedBaseline
+
+#ifdef FN_Cvar_DirectSet
+void FN_Cvar_DirectSet(struct cvar_s *var, char *value);
+#endif // FN_Cvar_DirectSet
+
+#ifdef FN_ForceUnmodified
+void FN_ForceUnmodified(FORCE_TYPE type, float *mins, float *maxs, const char *filename);
+#endif // FN_ForceUnmodified
+
+#ifdef FN_GetPlayerStats
+void FN_GetPlayerStats(const edict_t *pClient, int *ping, int *packet_loss);
+#endif // FN_GetPlayerStats
+
+#ifdef FN_AddServerCommand
+void FN_AddServerCommand(char *cmd_name, void (*function) (void));
+#endif // FN_AddServerCommand
+
+#ifdef FN_Voice_GetClientListening
+qboolean FN_Voice_GetClientListening(int iReceiver, int iSender);
+#endif // FN_Voice_GetClientListening
+
+#ifdef FN_Voice_SetClientListening
+qboolean FN_Voice_SetClientListening(int iReceiver, int iSender, qboolean bListen);
+#endif // FN_Voice_SetClientListening
+
+#ifdef FN_GetPlayerAuthId
+const char *FN_GetPlayerAuthId(edict_t *e);
+#endif // FN_GetPlayerAuthId
+
+
+
+
+
+
+#ifdef FN_PrecacheModel_Post
+int FN_PrecacheModel_Post(char *s);
+#endif // FN_PrecacheModel_Post
+
+#ifdef FN_PrecacheSound_Post
+int FN_PrecacheSound_Post(char *s);
+#endif // FN_PrecacheSound_Post
+
+#ifdef FN_SetModel_Post
+void FN_SetModel_Post(edict_t *e, const char *m);
+#endif // FN_SetModel_Post
+
+#ifdef FN_ModelIndex_Post
+int FN_ModelIndex_Post(const char *m);
+#endif // FN_ModelIndex_Post
+
+#ifdef FN_ModelFrames_Post
+int FN_ModelFrames_Post(int modelIndex);
+#endif // FN_ModelFrames_Post
+
+#ifdef FN_SetSize_Post
+void FN_SetSize_Post(edict_t *e, const float *rgflMin, const float *rgflMax);
+#endif // FN_SetSize_Post
+
+#ifdef FN_ChangeLevel_Post
+void FN_ChangeLevel_Post(char *s1, char *s2);
+#endif // FN_ChangeLevel_Post
+
+#ifdef FN_GetSpawnParms_Post
+void FN_GetSpawnParms_Post(edict_t *ent);
+#endif // FN_GetSpawnParms_Post
+
+#ifdef FN_SaveSpawnParms_Post
+void FN_SaveSpawnParms_Post(edict_t *ent);
+#endif // FN_SaveSpawnParms_Post
+
+#ifdef FN_VecToYaw_Post
+float FN_VecToYaw_Post(const float *rgflVector);
+#endif // FN_VecToYaw_Post
+
+#ifdef FN_VecToAngles_Post
+void FN_VecToAngles_Post(const float *rgflVectorIn, float *rgflVectorOut);
+#endif // FN_VecToAngles_Post
+
+#ifdef FN_MoveToOrigin_Post
+void FN_MoveToOrigin_Post(edict_t *ent, const float *pflGoal, float dist, int iMoveType);
+#endif // FN_MoveToOrigin_Post
+
+#ifdef FN_ChangeYaw_Post
+void FN_ChangeYaw_Post(edict_t *ent);
+#endif // FN_ChangeYaw_Post
+
+#ifdef FN_ChangePitch_Post
+void FN_ChangePitch_Post(edict_t *ent);
+#endif // FN_ChangePitch_Post
+
+#ifdef FN_FindEntityByString_Post
+edict_t *FN_FindEntityByString_Post(edict_t *pEdictStartSearchAfter, const char *pszField, const char *pszValue);
+#endif // FN_FindEntityByString_Post
+
+#ifdef FN_GetEntityIllum_Post
+int FN_GetEntityIllum_Post(edict_t *pEnt);
+#endif // FN_GetEntityIllum_Post
+
+#ifdef FN_FindEntityInSphere_Post
+edict_t *FN_FindEntityInSphere_Post(edict_t *pEdictStartSearchAfter, const float *org, float rad);
+#endif // FN_FindEntityInSphere_Post
+
+#ifdef FN_FindClientInPVS_Post
+edict_t *FN_FindClientInPVS_Post(edict_t *pEdict);
+#endif // FN_FindClientInPVS_Post
+
+#ifdef FN_EntitiesInPVS_Post
+edict_t *FN_EntitiesInPVS_Post(edict_t *pplayer);
+#endif // FN_EntitiesInPVS_Post
+
+#ifdef FN_MakeVectors_Post
+void FN_MakeVectors_Post(const float *rgflVector);
+#endif // FN_MakeVectors_Post
+
+#ifdef FN_AngleVectors_Post
+void FN_AngleVectors_Post(const float *rgflVector, float *forward, float *right, float *up);
+#endif // FN_AngleVectors_Post
+
+#ifdef FN_CreateEntity_Post
+edict_t *FN_CreateEntity_Post(void);
+#endif // FN_CreateEntity_Post
+
+#ifdef FN_RemoveEntity_Post
+void FN_RemoveEntity_Post(edict_t *e);
+#endif // FN_RemoveEntity_Post
+
+#ifdef FN_CreateNamedEntity_Post
+edict_t *FN_CreateNamedEntity_Post(int className);
+#endif // FN_CreateNamedEntity_Post
+
+#ifdef FN_MakeStatic_Post
+void FN_MakeStatic_Post(edict_t *ent);
+#endif // FN_MakeStatic_Post
+
+#ifdef FN_EntIsOnFloor_Post
+int FN_EntIsOnFloor_Post(edict_t *ent);
+#endif // FN_EntIsOnFloor_Post
+
+#ifdef FN_DropToFloor_Post
+int FN_DropToFloor_Post(edict_t *ent);
+#endif // FN_DropToFloor_Post
+
+#ifdef FN_WalkMove_Post
+int FN_WalkMove_Post(edict_t *ent, float yaw, float dist, int iMode);
+#endif // FN_WalkMove_Post
+
+#ifdef FN_SetOrigin_Post
+void FN_SetOrigin_Post(edict_t *e, const float *rgflOrigin);
+#endif // FN_SetOrigin_Post
+
+#ifdef FN_EmitSound_Post
+void FN_EmitSound_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitSound_Post
+
+#ifdef FN_EmitAmbientSound_Post
+void FN_EmitAmbientSound_Post(edict_t *entity, float *pos, const char *samp, float vol, float attenuation, int fFlags, int pitch);
+#endif // FN_EmitAmbientSound_Post
+
+#ifdef FN_TraceLine_Post
+void FN_TraceLine_Post(const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceLine_Post
+
+#ifdef FN_TraceToss_Post
+void FN_TraceToss_Post(edict_t *pent, edict_t *pentToIgnore, TraceResult *ptr);
+#endif // FN_TraceToss_Post
+
+#ifdef FN_TraceMonsterHull_Post
+int FN_TraceMonsterHull_Post(edict_t *pEdict, const float *v1, const float *v2, int fNoMonsters, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceMonsterHull_Post
+
+#ifdef FN_TraceHull_Post
+void FN_TraceHull_Post(const float *v1, const float *v2, int fNoMonsters, int hullNumber, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceHull_Post
+
+#ifdef FN_TraceModel_Post
+void FN_TraceModel_Post(const float *v1, const float *v2, int hullNumber, edict_t *pent, TraceResult *ptr);
+#endif // FN_TraceModel_Post
+
+#ifdef FN_TraceTexture_Post
+const char *FN_TraceTexture_Post(edict_t *pTextureEntity, const float *v1, const float *v2 );
+#endif // FN_TraceTexture_Post
+
+#ifdef FN_TraceSphere_Post
+void FN_TraceSphere_Post(const float *v1, const float *v2, int fNoMonsters, float radius, edict_t *pentToSkip, TraceResult *ptr);
+#endif // FN_TraceSphere_Post
+
+#ifdef FN_GetAimVector_Post
+void FN_GetAimVector_Post(edict_t *ent, float speed, float *rgflReturn);
+#endif // FN_GetAimVector_Post
+
+#ifdef FN_ServerCommand_Post
+void FN_ServerCommand_Post(char *str);
+#endif // FN_ServerCommand_Post
+
+#ifdef FN_ServerExecute_Post
+void FN_ServerExecute_Post(void);
+#endif // FN_ServerExecute_Post
+
+#ifdef FN_engClientCommand_Post
+void FN_engClientCommand_Post(edict_t *pEdict, char *szFmt, ...);
+#endif // FN_engClientCommand_Post
+
+#ifdef FN_ParticleEffect_Post
+void FN_ParticleEffect_Post(const float *org, const float *dir, float color, float count);
+#endif // FN_ParticleEffect_Post
+
+#ifdef FN_LightStyle_Post
+void FN_LightStyle_Post(int style, char *val);
+#endif // FN_LightStyle_Post
+
+#ifdef FN_DecalIndex_Post
+int FN_DecalIndex_Post(const char *name);
+#endif // FN_DecalIndex_Post
+
+#ifdef FN_PointContents_Post
+int FN_PointContents_Post(const float *rgflVector);
+#endif // FN_PointContents_Post
+
+#ifdef FN_MessageBegin_Post
+void FN_MessageBegin_Post(int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_MessageBegin_Post
+
+#ifdef FN_MessageEnd_Post
+void FN_MessageEnd_Post(void);
+#endif // FN_MessageEnd_Post
+
+#ifdef FN_WriteByte_Post
+void FN_WriteByte_Post(int iValue);
+#endif // FN_WriteByte_Post
+
+#ifdef FN_WriteChar_Post
+void FN_WriteChar_Post(int iValue);
+#endif // FN_WriteChar_Post
+
+#ifdef FN_WriteShort_Post
+void FN_WriteShort_Post(int iValue);
+#endif // FN_WriteShort_Post
+
+#ifdef FN_WriteLong_Post
+void FN_WriteLong_Post(int iValue);
+#endif // FN_WriteLong_Post
+
+#ifdef FN_WriteAngle_Post
+void FN_WriteAngle_Post(float flValue);
+#endif // FN_WriteAngle_Post
+
+#ifdef FN_WriteCoord_Post
+void FN_WriteCoord_Post(float flValue);
+#endif // FN_WriteCoord_Post
+
+#ifdef FN_WriteString_Post
+void FN_WriteString_Post(const char *sz);
+#endif // FN_WriteString_Post
+
+#ifdef FN_WriteEntity_Post
+void FN_WriteEntity_Post(int iValue);
+#endif // FN_WriteEntity_Post
+
+#ifdef FN_CVarRegister_Post
+void FN_CVarRegister_Post(cvar_t *pCvar);
+#endif // FN_CVarRegister_Post
+
+#ifdef FN_CVarGetFloat_Post
+float FN_CVarGetFloat_Post(const char *szVarName);
+#endif // FN_CVarGetFloat_Post
+
+#ifdef FN_CVarGetString_Post
+const char *FN_CVarGetString_Post(const char *szVarName);
+#endif // FN_CVarGetString_Post
+
+#ifdef FN_CVarSetFloat_Post
+void FN_CVarSetFloat_Post(const char *szVarName, float flValue);
+#endif // FN_CVarSetFloat_Post
+
+#ifdef FN_CVarSetString_Post
+void FN_CVarSetString_Post(const char *szVarName, const char *szValue);
+#endif // FN_CVarSetString_Post
+
+#ifdef FN_AlertMessage_Post
+void FN_AlertMessage_Post(ALERT_TYPE atype, char *szFmt, ...);
+#endif // FN_AlertMessage_Post
+
+#ifdef FN_EngineFprintf_Post
+void FN_EngineFprintf_Post(FILE *pfile, char *szFmt, ...);
+#endif // FN_EngineFprintf_Post
+
+#ifdef FN_PvAllocEntPrivateData_Post
+void *FN_PvAllocEntPrivateData_Post(edict_t *pEdict, long cb);
+#endif // FN_PvAllocEntPrivateData_Post
+
+#ifdef FN_PvEntPrivateData_Post
+void *FN_PvEntPrivateData_Post(edict_t *pEdict);
+#endif // FN_PvEntPrivateData_Post
+
+#ifdef FN_FreeEntPrivateData_Post
+void FN_FreeEntPrivateData_Post(edict_t *pEdict);
+#endif // FN_FreeEntPrivateData_Post
+
+#ifdef FN_SzFromIndex_Post
+const char *FN_SzFromIndex_Post(int iString);
+#endif // FN_SzFromIndex_Post
+
+#ifdef FN_AllocString_Post
+int FN_AllocString_Post(const char *szValue);
+#endif // FN_AllocString_Post
+
+#ifdef FN_GetVarsOfEnt_Post
+struct entvars_s *FN_GetVarsOfEnt_Post(edict_t *pEdict);
+#endif // FN_GetVarsOfEnt_Post
+
+#ifdef FN_PEntityOfEntOffset_Post
+edict_t *FN_PEntityOfEntOffset_Post(int iEntOffset);
+#endif // FN_PEntityOfEntOffset_Post
+
+#ifdef FN_EntOffsetOfPEntity_Post
+int FN_EntOffsetOfPEntity_Post(const edict_t *pEdict);
+#endif // FN_EntOffsetOfPEntity_Post
+
+#ifdef FN_IndexOfEdict_Post
+int FN_IndexOfEdict_Post(const edict_t *pEdict);
+#endif // FN_IndexOfEdict_Post
+
+#ifdef FN_PEntityOfEntIndex_Post
+edict_t *FN_PEntityOfEntIndex_Post(int iEntIndex);
+#endif // FN_PEntityOfEntIndex_Post
+
+#ifdef FN_FindEntityByVars_Post
+edict_t *FN_FindEntityByVars_Post(struct entvars_s *pvars);
+#endif // FN_FindEntityByVars_Post
+
+#ifdef FN_GetModelPtr_Post
+void *FN_GetModelPtr_Post(edict_t *pEdict);
+#endif // FN_GetModelPtr_Post
+
+#ifdef FN_RegUserMsg_Post
+int FN_RegUserMsg_Post(const char *pszName, int iSize);
+#endif // FN_RegUserMsg_Post
+
+#ifdef FN_AnimationAutomove_Post
+void FN_AnimationAutomove_Post(const edict_t *pEdict, float flTime);
+#endif // FN_AnimationAutomove_Post
+
+#ifdef FN_GetBonePosition_Post
+void FN_GetBonePosition_Post(const edict_t *pEdict, int iBone, float *rgflOrigin, float *rgflAngles);
+#endif // FN_GetBonePosition_Post
+
+#ifdef FN_FunctionFromName_Post
+unsigned long FN_FunctionFromName_Post(const char *pName);
+#endif // FN_FunctionFromName_Post
+
+#ifdef FN_NameForFunction_Post
+const char *FN_NameForFunction_Post(unsigned long function);
+#endif // FN_NameForFunction_Post
+
+#ifdef FN_ClientPrintf_Post
+void FN_ClientPrintf_Post(edict_t *pEdict, PRINT_TYPE ptype, const char *szMsg);
+#endif // FN_ClientPrintf_Post
+
+#ifdef FN_ServerPrint_Post
+void FN_ServerPrint_Post(const char *szMsg);
+#endif // FN_ServerPrint_Post
+
+#ifdef FN_Cmd_Args_Post
+const char *FN_Cmd_Args_Post(void);
+#endif // FN_Cmd_Args_Post
+
+#ifdef FN_Cmd_Argv_Post
+const char *FN_Cmd_Argv_Post(int argc);
+#endif // FN_Cmd_Argv_Post
+
+#ifdef FN_Cmd_Argc_Post
+int FN_Cmd_Argc_Post(void);
+#endif // FN_Cmd_Argc_Post
+
+#ifdef FN_GetAttachment_Post
+void FN_GetAttachment_Post(const edict_t *pEdict, int iAttachment, float *rgflOrigin, float *rgflAngles );
+#endif // FN_GetAttachment_Post
+
+#ifdef FN_CRC32_Init_Post
+void FN_CRC32_Init_Post(CRC32_t *pulCRC);
+#endif // FN_CRC32_Init_Post
+
+#ifdef FN_CRC32_ProcessBuffer_Post
+void FN_CRC32_ProcessBuffer_Post(CRC32_t *pulCRC, void *p, int len);
+#endif // FN_CRC32_ProcessBuffer_Post
+
+#ifdef FN_CRC32_ProcessByte_Post
+void FN_CRC32_ProcessByte_Post(CRC32_t *pulCRC, unsigned char ch);
+#endif // FN_CRC32_ProcessByte_Post
+
+#ifdef FN_CRC32_Final_Post
+CRC32_t FN_CRC32_Final_Post(CRC32_t pulCRC);
+#endif // FN_CRC32_Final_Post
+
+#ifdef FN_RandomLong_Post
+long FN_RandomLong_Post(long lLow, long lHigh);
+#endif // FN_RandomLong_Post
+
+#ifdef FN_RandomFloat_Post
+float FN_RandomFloat_Post(float flLow, float flHigh);
+#endif // FN_RandomFloat_Post
+
+#ifdef FN_SetView_Post
+void FN_SetView_Post(const edict_t *pClient, const edict_t *pViewent);
+#endif // FN_SetView_Post
+
+#ifdef FN_Time_Post
+float FN_Time_Post(void);
+#endif // FN_Time_Post
+
+#ifdef FN_CrosshairAngle_Post
+void FN_CrosshairAngle_Post(const edict_t *pClient, float pitch, float yaw);
+#endif // FN_CrosshairAngle_Post
+
+#ifdef FN_LoadFileForMe_Post
+byte *FN_LoadFileForMe_Post(char *filename, int *pLength);
+#endif // FN_LoadFileForMe_Post
+
+#ifdef FN_FreeFile_Post
+void FN_FreeFile_Post(void *buffer);
+#endif // FN_FreeFile_Post
+
+#ifdef FN_EndSection_Post
+void FN_EndSection_Post(const char *pszSectionName);
+#endif // FN_EndSection_Post
+
+#ifdef FN_CompareFileTime_Post
+int FN_CompareFileTime_Post(char *filename1, char *filename2, int *iCompare);
+#endif // FN_CompareFileTime_Post
+
+#ifdef FN_GetGameDir_Post
+void FN_GetGameDir_Post(char *szGetGameDir);
+#endif // FN_GetGameDir_Post
+
+#ifdef FN_Cvar_RegisterVariable_Post
+void FN_Cvar_RegisterVariable_Post(cvar_t *variable);
+#endif // FN_Cvar_RegisterVariable_Post
+
+#ifdef FN_FadeClientVolume_Post
+void FN_FadeClientVolume_Post(const edict_t *pEdict, int fadePercent, int fadeOutSeconds, int holdTime, int fadeInSeconds);
+#endif // FN_FadeClientVolume_Post
+
+#ifdef FN_SetClientMaxspeed_Post
+void FN_SetClientMaxspeed_Post(const edict_t *pEdict, float fNewMaxspeed);
+#endif // FN_SetClientMaxspeed_Post
+
+#ifdef FN_CreateFakeClient_Post
+edict_t *FN_CreateFakeClient_Post(const char *netname);
+#endif // FN_CreateFakeClient_Post
+
+#ifdef FN_RunPlayerMove_Post
+void FN_RunPlayerMove_Post(edict_t *fakeclient, const float *viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, byte msec);
+#endif // FN_RunPlayerMove_Post
+
+#ifdef FN_NumberOfEntities_Post
+int FN_NumberOfEntities_Post(void);
+#endif // FN_NumberOfEntities_Post
+
+#ifdef FN_GetInfoKeyBuffer_Post
+char *FN_GetInfoKeyBuffer_Post(edict_t *e);
+#endif // FN_GetInfoKeyBuffer_Post
+
+#ifdef FN_InfoKeyValue_Post
+char *FN_InfoKeyValue_Post(char *infobuffer, char *key);
+#endif // FN_InfoKeyValue_Post
+
+#ifdef FN_SetKeyValue_Post
+void FN_SetKeyValue_Post(char *infobuffer, char *key, char *value);
+#endif // FN_SetKeyValue_Post
+
+#ifdef FN_SetClientKeyValue_Post
+void FN_SetClientKeyValue_Post(int clientIndex, char *infobuffer, char *key, char *value);
+#endif // FN_SetClientKeyValue_Post
+
+#ifdef FN_IsMapValid_Post
+int FN_IsMapValid_Post(char *filename);
+#endif // FN_IsMapValid_Post
+
+#ifdef FN_StaticDecal_Post
+void FN_StaticDecal_Post(const float *origin, int decalIndex, int entityIndex, int modelIndex);
+#endif // FN_StaticDecal_Post
+
+#ifdef FN_PrecacheGeneric_Post
+int FN_PrecacheGeneric_Post(char *s);
+#endif // FN_PrecacheGeneric_Post
+
+#ifdef FN_GetPlayerUserId_Post
+int FN_GetPlayerUserId_Post(edict_t *e );
+#endif // FN_GetPlayerUserId_Post
+
+#ifdef FN_BuildSoundMsg_Post
+void FN_BuildSoundMsg_Post(edict_t *entity, int channel, const char *sample, /*int*/float volume, float attenuation, int fFlags, int pitch, int msg_dest, int msg_type, const float *pOrigin, edict_t *ed);
+#endif // FN_BuildSoundMsg_Post
+
+#ifdef FN_IsDedicatedServer_Post
+int FN_IsDedicatedServer_Post(void);
+#endif // FN_IsDedicatedServer_Post
+
+#ifdef FN_CVarGetPointer_Post
+cvar_t *FN_CVarGetPointer_Post(const char *szVarName);
+#endif // FN_CVarGetPointer_Post
+
+#ifdef FN_GetPlayerWONId_Post
+unsigned int FN_GetPlayerWONId_Post(edict_t *e);
+#endif // FN_GetPlayerWONId_Post
+
+#ifdef FN_Info_RemoveKey_Post
+void FN_Info_RemoveKey_Post( char *s, const char *key);
+#endif // FN_Info_RemoveKey_Post
+
+#ifdef FN_GetPhysicsKeyValue_Post
+const char *FN_GetPhysicsKeyValue_Post(const edict_t *pClient, const char *key);
+#endif // FN_GetPhysicsKeyValue_Post
+
+#ifdef FN_SetPhysicsKeyValue_Post
+void FN_SetPhysicsKeyValue_Post(const edict_t *pClient, const char *key, const char *value);
+#endif // FN_SetPhysicsKeyValue_Post
+
+#ifdef FN_GetPhysicsInfoString_Post
+const char *FN_GetPhysicsInfoString_Post( const edict_t *pClient);
+#endif // FN_GetPhysicsInfoString_Post
+
+#ifdef FN_PrecacheEvent_Post
+unsigned short FN_PrecacheEvent_Post(int type, const char *psz);
+#endif // FN_PrecacheEvent_Post
+
+#ifdef FN_PlaybackEvent_Post
+void FN_PlaybackEvent_Post(int flags, const edict_t *pInvoker, unsigned short eventindex, float delay, float *origin, float *angles, float fparam1, float fparam2, int iparam1, int iparam2, int bparam1, int bparam2);
+#endif // FN_PlaybackEvent_Post
+
+#ifdef FN_SetFatPVS_Post
+unsigned char *FN_SetFatPVS_Post(float *org);
+#endif // FN_SetFatPVS_Post
+
+#ifdef FN_SetFatPAS_Post
+unsigned char *FN_SetFatPAS_Post(float *org);
+#endif // FN_SetFatPAS_Post
+
+#ifdef FN_CheckVisibility_Post
+int FN_CheckVisibility_Post(const edict_t *entity, unsigned char *pset);
+#endif // FN_CheckVisibility_Post
+
+#ifdef FN_DeltaSetField_Post
+void FN_DeltaSetField_Post(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaSetField_Post
+
+#ifdef FN_DeltaUnsetField_Post
+void FN_DeltaUnsetField_Post(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaUnsetField_Post
+
+#ifdef FN_DeltaAddEncoder_Post
+void FN_DeltaAddEncoder_Post(char *name, void (*conditionalencode)( struct delta_s *pFields, const unsigned char *from, const unsigned char *to ) );
+#endif // FN_DeltaAddEncoder_Post
+
+#ifdef FN_GetCurrentPlayer_Post
+int FN_GetCurrentPlayer_Post(void);
+#endif // FN_GetCurrentPlayer_Post
+
+#ifdef FN_CanSkipPlayer_Post
+int FN_CanSkipPlayer_Post(const edict_t *player);
+#endif // FN_CanSkipPlayer_Post
+
+#ifdef FN_DeltaFindField_Post
+int FN_DeltaFindField_Post(struct delta_s *pFields, const char *fieldname);
+#endif // FN_DeltaFindField_Post
+
+#ifdef FN_DeltaSetFieldByIndex_Post
+void FN_DeltaSetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaSetFieldByIndex_Post
+
+#ifdef FN_DeltaUnsetFieldByIndex_Post
+void FN_DeltaUnsetFieldByIndex_Post(struct delta_s *pFields, int fieldNumber);
+#endif // FN_DeltaUnsetFieldByIndex_Post
+
+#ifdef FN_SetGroupMask_Post
+void FN_SetGroupMask_Post(int mask, int op);
+#endif // FN_SetGroupMask_Post
+
+#ifdef FN_engCreateInstancedBaseline_Post
+int FN_engCreateInstancedBaseline_Post(int classname, struct entity_state_s *baseline);
+#endif // FN_engCreateInstancedBaseline_Post
+
+#ifdef FN_Cvar_DirectSet_Post
+void FN_Cvar_DirectSet_Post(struct cvar_s *var, char *value);
+#endif // FN_Cvar_DirectSet_Post
+
+#ifdef FN_ForceUnmodified_Post
+void FN_ForceUnmodified_Post(FORCE_TYPE type, float *mins, float *maxs, const char *filename);
+#endif // FN_ForceUnmodified_Post
+
+#ifdef FN_GetPlayerStats_Post
+void FN_GetPlayerStats_Post(const edict_t *pClient, int *ping, int *packet_loss);
+#endif // FN_GetPlayerStats_Post
+
+#ifdef FN_AddServerCommand_Post
+void FN_AddServerCommand_Post(char *cmd_name, void (*function)(void));
+#endif // FN_AddServerCommand_Post
+
+#ifdef FN_Voice_GetClientListening_Post
+qboolean FN_Voice_GetClientListening_Post(int iReceiver, int iSender);
+#endif // FN_Voice_GetClientListening_Post
+
+#ifdef FN_Voice_SetClientListening_Post
+qboolean FN_Voice_SetClientListening_Post(int iReceiver, int iSender, qboolean bListen);
+#endif // FN_Voice_SetClientListening_Post
+
+#ifdef FN_GetPlayerAuthId_Post
+const char *FN_GetPlayerAuthId_Post(edict_t *e);
+#endif // FN_GetPlayerAuthId
+
+
+
+
+#ifdef FN_OnFreeEntPrivateData
+void FN_OnFreeEntPrivateData(edict_t *pEnt);
+#endif // FN_OnFreeEntPrivateData
+
+#ifdef FN_GameShutdown
+void FN_GameShutdown(void);
+#endif // FN_GameShutdown
+
+#ifdef FN_ShouldCollide
+int FN_ShouldCollide(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_ShouldCollide
+
+
+
+
+
+#ifdef FN_OnFreeEntPrivateData_Post
+void FN_OnFreeEntPrivateData_Post(edict_t *pEnt);
+#endif // FN_OnFreeEntPrivateData_Post
+
+#ifdef FN_GameShutdown_Post
+void FN_GameShutdown_Post(void);
+#endif // FN_GameShutdown_Post
+
+#ifdef FN_ShouldCollide_Post
+int FN_ShouldCollide_Post(edict_t *pentTouched, edict_t *pentOther);
+#endif // FN_ShouldCollide_Post
+
+#endif // USE_METAMOD
+
+
+#ifdef FN_AMXX_QUERY
+void FN_AMXX_QUERY(void);
+#endif // FN_AMXX_QUERY
+
+#ifdef FN_AMXX_ATTACH
+void FN_AMXX_ATTACH(void);
+#endif // FN_AMXX_ATTACH
+
+#ifdef FN_AMXX_DETACH
+void FN_AMXX_DETACH(void);
+#endif // FN_AMXX_DETACH
+
+#ifdef FN_AMXX_PLUGINSLOADED
+void FN_AMXX_PLUGINSLOADED(void);
+#endif // FN_AMXX_PLUGINSLOADED
+
+// ***** Module funcs stuff *****
+enum ForwardExecType
+{
+	ET_IGNORE = 0,					// Ignore return vaue
+	ET_STOP,						// Stop on PLUGIN_HANDLED
+	ET_STOP2,						// Stop on PLUGIN_HANDLED, continue on other values, return biggest return value
+	ET_CONTINUE,					// Continue; return biggest return value
+};
+
+enum ForwardParam
+{
+	FP_DONE = -1,					// specify this as the last argument
+									// only tells the function that there are no more arguments
+	FP_CELL,						// normal cell
+	FP_FLOAT,						// float; used as normal cell though
+	FP_STRING,						// string
+	FP_STRINGEX,					// string; will be updated to the last function's value
+	FP_ARRAY,						// array; use the return value of prepareArray.
+};
+
+
+typedef int				(*PFN_ADD_NATIVES)				(const AMX_NATIVE_INFO * /*list*/);
+typedef char *			(*PFN_BUILD_PATHNAME)			(const char * /*format*/, ...);
+typedef cell *			(*PFN_GET_AMXADDR)				(AMX * /*amx*/, cell /*offset*/);
+typedef void			(*PFN_PRINT_SRVCONSOLE)			(char * /*format*/, ...);
+typedef const char *	(*PFN_GET_MODNAME)				(void);
+typedef const char *	(*PFN_GET_AMXSCRIPTNAME)		(int /*id*/);
+typedef AMX *			(*PFN_GET_AMXSCRIPT)			(int /*id*/);
+typedef int				(*PFN_FIND_AMXSCRIPT_BYAMX)		(const AMX * /*amx*/);
+typedef int				(*PFN_FIND_AMXSCRIPT_BYNAME)	(const char * /*name*/);
+typedef int				(*PFN_SET_AMXSTRING)			(AMX * /*amx*/, cell /*amx_addr*/, const char * /* source */, int /* max */);
+typedef char *			(*PFN_GET_AMXSTRING)			(AMX * /*amx*/, cell /*amx_addr*/, int /*bufferId*/, int * /*pLen*/);
+typedef int				(*PFN_GET_AMXSTRINGLEN)			(const cell *ptr);
+typedef char *			(*PFN_FORMAT_AMXSTRING)			(AMX * /*amx*/, cell * /*params*/, int /*startParam*/, int * /*pLen*/);
+typedef void			(*PFN_COPY_AMXMEMORY)			(cell * /*dest*/, const cell * /*src*/, int /*len*/);
+typedef void			(*PFN_LOG)						(const char * /*fmt*/, ...);
+typedef void			(*PFN_LOG_ERROR)				(AMX * /*amx*/, int /*err*/, const char * /*fmt*/, ...);
+typedef int				(*PFN_RAISE_AMXERROR)			(AMX * /*amx*/, int /*error*/);
+typedef int				(*PFN_REGISTER_FORWARD)			(const char * /*funcname*/, ForwardExecType /*exectype*/, ... /*paramtypes terminated by PF_DONE*/);
+typedef int				(*PFN_EXECUTE_FORWARD)			(int /*id*/, ... /*params*/);
+typedef cell			(*PFN_PREPARE_CELLARRAY)		(cell * /*ptr*/, unsigned int /*size*/);
+typedef cell			(*PFN_PREPARE_CHARARRAY)		(char * /*ptr*/, unsigned int /*size*/);
+typedef cell			(*PFN_PREPARE_CELLARRAY_A)		(cell * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/);
+typedef cell			(*PFN_PREPARE_CHARARRAY_A)		(char * /*ptr*/, unsigned int /*size*/, bool /*copyBack*/);
+typedef int				(*PFN_IS_PLAYER_VALID)			(int /*id*/);
+typedef const char *	(*PFN_GET_PLAYER_NAME)			(int /*id*/);
+typedef const char *	(*PFN_GET_PLAYER_IP)			(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_INGAME)			(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_BOT)			(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_AUTHORIZED)		(int /*id*/);
+typedef float			(*PFN_GET_PLAYER_TIME)			(int /*id*/);
+typedef float			(*PFN_GET_PLAYER_PLAYTIME)		(int /*id*/);
+typedef int				(*PFN_GETPLAYERFLAGS) 			(int /* id*/);
+typedef int				(*PFN_GET_PLAYER_CURWEAPON)		(int /*id*/);
+typedef const char *    (*PFN_GET_PLAYER_TEAM)			(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_TEAMID)		(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_DEATHS)		(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_MENU)			(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_KEYS)			(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_ALIVE)			(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_FRAGS)			(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_CONNECTING)		(int /*id*/);
+typedef int				(*PFN_IS_PLAYER_HLTV)			(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_ARMOR)			(int /*id*/);
+typedef int				(*PFN_GET_PLAYER_HEALTH)		(int /*id*/);
+#ifdef USE_METAMOD
+typedef edict_t *		(*PFN_GET_PLAYER_EDICT)			(int /*id*/);
+#else
+typedef void *			(*PFN_GET_PLAYER_EDICT)			(int /*id*/);
+#endif
+
+typedef void *			(*PFN_ALLOCATOR)				(const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
+														 const unsigned int /*type*/, const size_t /*size*/);
+typedef void *			(*PFN_REALLOCATOR)				(const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
+														 const unsigned int /*type*/, const size_t /*size*/, void* /*addr*/ );
+typedef void			(*PFN_DEALLOCATOR)				(const char* /*filename*/, const unsigned int /*line*/, const char* /*func*/,
+														 const unsigned int /*type*/, const void* /*addr*/ );
+typedef int				(*PFN_AMX_EXEC)					(AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, ... /*params*/);
+typedef int				(*PFN_AMX_EXECV)				(AMX* /*amx*/, cell* /*return val*/, int /*index*/, int /*numparams*/, cell[] /*params*/);
+typedef int				(*PFN_AMX_ALLOT)				(AMX* /*amx*/, int /*length*/, cell* /*amx_addr*/, cell** /*phys_addr*/);
+typedef int				(*PFN_AMX_FINDPUBLIC)			(AMX* /*amx*/, char* /*func name*/, int* /*index*/);
+typedef int				(*PFN_AMX_FINDNATIVE)			(AMX* /*amx*/, char* /*func name*/, int* /*index*/);
+typedef int				(*PFN_LOAD_AMXSCRIPT)			(AMX* /*amx*/, void** /*code*/, const char* /*path*/, char[64] /*error info*/, int /* debug */);
+typedef int				(*PFN_UNLOAD_AMXSCRIPT)			(AMX* /*amx*/,void** /*code*/);
+typedef cell			(*PFN_REAL_TO_CELL)				(REAL /*x*/);
+typedef REAL			(*PFN_CELL_TO_REAL)				(cell /*x*/);
+typedef int				(*PFN_REGISTER_SPFORWARD)		(AMX * /*amx*/, int /*func*/, ... /*params*/);
+typedef int				(*PFN_REGISTER_SPFORWARD_BYNAME)	(AMX * /*amx*/, const char * /*funcName*/, ... /*params*/);
+typedef void			(*PFN_UNREGISTER_SPFORWARD)		(int /*id*/);
+typedef	void			(*PFN_MERGEDEFINITION_FILE)		(const char * /*filename*/);
+typedef const char *	(*PFN_FORMAT)					(const char * /*fmt*/, ... /*params*/);
+
+extern PFN_ADD_NATIVES				g_fn_AddNatives;
+extern PFN_BUILD_PATHNAME			g_fn_BuildPathname;
+extern PFN_GET_AMXADDR				g_fn_GetAmxAddr;
+extern PFN_PRINT_SRVCONSOLE			g_fn_PrintSrvConsole;
+extern PFN_GET_MODNAME				g_fn_GetModname;
+extern PFN_GET_AMXSCRIPTNAME		g_fn_GetAmxScriptName;
+extern PFN_GET_AMXSCRIPT			g_fn_GetAmxScript;
+extern PFN_FIND_AMXSCRIPT_BYAMX		g_fn_FindAmxScriptByAmx;
+extern PFN_FIND_AMXSCRIPT_BYNAME	g_fn_FindAmxScriptByName;
+extern PFN_SET_AMXSTRING			g_fn_SetAmxString;
+extern PFN_GET_AMXSTRING			g_fn_GetAmxString;
+extern PFN_GET_AMXSTRINGLEN			g_fn_GetAmxStringLen;
+extern PFN_FORMAT_AMXSTRING			g_fn_FormatAmxString;
+extern PFN_COPY_AMXMEMORY			g_fn_CopyAmxMemory;
+extern PFN_LOG						g_fn_Log;
+extern PFN_LOG_ERROR				g_fn_LogErrorFunc;
+extern PFN_RAISE_AMXERROR			g_fn_RaiseAmxError;
+extern PFN_REGISTER_FORWARD			g_fn_RegisterForward;
+extern PFN_EXECUTE_FORWARD			g_fn_ExecuteForward;
+extern PFN_PREPARE_CELLARRAY		g_fn_PrepareCellArray;
+extern PFN_PREPARE_CHARARRAY		g_fn_PrepareCharArray;
+extern PFN_PREPARE_CELLARRAY_A		g_fn_PrepareCellArrayA;
+extern PFN_PREPARE_CHARARRAY_A		g_fn_PrepareCharArrayA;
+extern PFN_IS_PLAYER_VALID			g_fn_IsPlayerValid;
+extern PFN_GET_PLAYER_NAME			g_fn_GetPlayerName;
+extern PFN_GET_PLAYER_IP			g_fn_GetPlayerIP;
+extern PFN_IS_PLAYER_INGAME			g_fn_IsPlayerIngame;
+extern PFN_IS_PLAYER_BOT			g_fn_IsPlayerBot;
+extern PFN_IS_PLAYER_AUTHORIZED		g_fn_IsPlayerAuthorized;
+extern PFN_GET_PLAYER_TIME			g_fn_GetPlayerTime;
+extern PFN_GET_PLAYER_PLAYTIME		g_fn_GetPlayerPlayTime;
+extern PFN_GET_PLAYER_CURWEAPON		g_fn_GetPlayerCurweapon;
+extern PFN_GET_PLAYER_TEAMID		g_fn_GetPlayerTeamID;
+extern PFN_GET_PLAYER_DEATHS		g_fn_GetPlayerDeaths;
+extern PFN_GET_PLAYER_MENU			g_fn_GetPlayerMenu;
+extern PFN_GET_PLAYER_KEYS			g_fn_GetPlayerKeys;
+extern PFN_IS_PLAYER_ALIVE			g_fn_IsPlayerAlive;
+extern PFN_GET_PLAYER_FRAGS			g_fn_GetPlayerFrags;
+extern PFN_IS_PLAYER_CONNECTING		g_fn_IsPlayerConnecting;
+extern PFN_IS_PLAYER_HLTV			g_fn_IsPlayerHLTV;
+extern PFN_GET_PLAYER_ARMOR			g_fn_GetPlayerArmor;
+extern PFN_GET_PLAYER_HEALTH		g_fn_GetPlayerHealth;
+extern PFN_AMX_EXEC					g_fn_AmxExec;
+extern PFN_AMX_EXECV				g_fn_AmxExecv;
+extern PFN_AMX_ALLOT				g_fn_AmxAllot;
+extern PFN_AMX_FINDPUBLIC			g_fn_AmxFindPublic;
+extern PFN_LOAD_AMXSCRIPT			g_fn_LoadAmxScript;
+extern PFN_UNLOAD_AMXSCRIPT			g_fn_UnloadAmxScript;
+extern PFN_REAL_TO_CELL				g_fn_RealToCell;
+extern PFN_CELL_TO_REAL				g_fn_CellToReal;
+extern PFN_REGISTER_SPFORWARD		g_fn_RegisterSPForward;
+extern PFN_REGISTER_SPFORWARD_BYNAME	g_fn_RegisterSPForwardByName;
+extern PFN_UNREGISTER_SPFORWARD		g_fn_UnregisterSPForward;
+extern PFN_MERGEDEFINITION_FILE		g_fn_MergeDefinition_File;
+extern PFN_AMX_FINDNATIVE			g_fn_AmxFindNative;
+extern PFN_GETPLAYERFLAGS		g_fn_GetPlayerFlags;
+extern PFN_GET_PLAYER_EDICT			g_fn_GetPlayerEdict;
+extern PFN_FORMAT					g_fn_Format;
+extern PFN_GET_PLAYER_TEAM			g_fn_GetPlayerTeam;
+
+#ifdef MAY_NEVER_BE_DEFINED
+// Function prototypes for intellisense and similar systems
+// They understand #if 0 so we use #ifdef MAY_NEVER_BE_DEFINED
+int				MF_AddNatives				(const AMX_NATIVE_INFO *list) { }
+char *			MF_BuildPathname			(const char * format, ...) { }
+cell *			MF_GetAmxAddr				(AMX * amx, cell offset) { }
+void			MF_PrintSrvConsole			(char * format, ...) { }
+const char *	MF_GetModname				(void) { }
+const char *	MF_GetScriptName			(int id) { }
+AMX *			MF_GetScriptAmx				(int id) { }
+int				MF_FindScriptByAmx			(const AMX * amx) { }
+int				MF_FindScriptByAmx			(const char * name) { }
+int				MF_SetAmxString				(AMX * amx, cell amx_addr, const char *  source , int  max ) { }
+char *			MF_GetAmxString				(AMX * amx, cell amx_addr, int bufferId, int * pLen) { }
+int				MF_GetAmxStringLen			(const cell *ptr) { }
+char *			MF_FormatAmxString			(AMX * amx, cell * params, int startParam, int * pLen) { }
+void			MF_CopyAmxMemory			(cell * dest, const cell * src, int len) { }
+void			MF_Log						(const char * fmt, ...) { }
+void			MF_LogError					(AMX * amx, int err, const char *fmt, ...) { }
+int				MF_RaiseAmxError			(AMX * amx, int error) { }
+int				MF_RegisterForward			(const char * funcname, ForwardExecType exectype, ...) { }
+int				MF_ExecuteForward			(int id, ...) { }
+cell			MF_PrepareCellArray			(cell * ptr, unsigned int size) { }
+cell			MF_PrepareCharArray			(char * ptr, unsigned int size) { }
+cell			MF_PrepareCellArrayA			(cell * ptr, unsigned int size, bool copyBack) { }
+cell			MF_PrepareCharArrayA			(char * ptr, unsigned int size, bool copyBack) { }
+int				MF_IsPlayerValid			(int id) { }
+const char *	MF_GetPlayerName			(int id) { }
+const char *	MF_GetPlayerIP				(int id) { }
+int				MF_IsPlayerIngame			(int id) { }
+int				MF_IsPlayerBot				(int id) { }
+int				MF_IsPlayerAuthorized		(int id) { }
+float			MF_GetPlayerTime			(int id) { }
+float			MF_GetPlayerPlayTime		(int id) { }
+int				MF_GetPlayerCurweapon		(int id) { }
+const char *	MF_GetPlayerTeam			(int id) { }
+int				MF_GetPlayerTeamID			(int id) { }
+int				MF_GetPlayerDeaths			(int id) { }
+int				MF_GetPlayerMenu			(int id) { }
+int				MF_GetPlayerKeys			(int id) { }
+int				MF_IsPlayerAlive			(int id) { }
+int				MF_GetPlayerFrags			(int id) { }
+int				MF_IsPlayerConnecting		(int id) { }
+int				MF_IsPlayerHLTV				(int id) { }
+int				MF_GetPlayerArmor			(int id) { }
+int				MF_GetPlayerHealth			(int id) { }
+REAL			amx_ctof					(cell x) { }
+cell			amx_ftoc					(float x) { }
+int				MF_RegisterSPForwardByName	(AMX * amx, const char *str, ...) { }
+int				MF_RegisterSPForward		(AMX * amx, int func, ...) { }
+void			MF_UnregisterSPForward		(int id) { }
+int				MF_GetPlayerFlags			(int id) { }
+edict_t*		MF_GetPlayerEdict			(int id) { }
+const char *	MF_Format					(const char *fmt, ...) { }
+#endif	// MAY_NEVER_BE_DEFINED
+
+#define MF_AddNatives g_fn_AddNatives
+#define MF_BuildPathname g_fn_BuildPathname
+#define MF_FormatAmxString g_fn_FormatAmxString
+#define MF_GetAmxAddr g_fn_GetAmxAddr
+#define MF_PrintSrvConsole g_fn_PrintSrvConsole
+#define MF_GetModname g_fn_GetModname
+#define MF_GetScriptName g_fn_GetAmxScriptName
+#define MF_GetScriptAmx g_fn_GetAmxScript
+#define MF_FindScriptByAmx g_fn_FindAmxScriptByAmx
+#define MF_FindScriptByName g_fn_FindAmxScriptByName
+#define MF_SetAmxString g_fn_SetAmxString
+#define MF_GetAmxString g_fn_GetAmxString
+#define MF_GetAmxStringLen g_fn_GetAmxStringLen
+#define MF_CopyAmxMemory g_fn_CopyAmxMemory
+void MF_Log(const char *fmt, ...);
+void MF_LogError(AMX *amx, int err, const char *fmt, ...);
+#define MF_RaiseAmxError g_fn_RaiseAmxError
+#define MF_RegisterForward g_fn_RegisterForward
+#define MF_ExecuteForward g_fn_ExecuteForward
+#define MF_PrepareCellArray g_fn_PrepareCellArray
+#define MF_PrepareCharArray g_fn_PrepareCharArray
+#define MF_PrepareCellArrayA g_fn_PrepareCellArrayA
+#define MF_PrepareCharArrayA g_fn_PrepareCharArrayA
+#define MF_IsPlayerValid g_fn_IsPlayerValid
+#define MF_GetPlayerName g_fn_GetPlayerName
+#define MF_GetPlayerIP g_fn_GetPlayerIP
+#define MF_IsPlayerIngame g_fn_IsPlayerIngame
+#define MF_IsPlayerBot g_fn_IsPlayerBot
+#define MF_IsPlayerAuthorized g_fn_IsPlayerAuthorized
+#define MF_GetPlayerTime g_fn_GetPlayerTime
+#define MF_GetPlayerPlayTime g_fn_GetPlayerPlayTime
+#define MF_GetPlayerCurweapon g_fn_GetPlayerCurweapon
+#define MF_GetPlayerTeam g_fn_GetPlayerTeam
+#define MF_GetPlayerTeamID g_fn_GetPlayerTeamID
+#define MF_GetPlayerDeaths g_fn_GetPlayerDeaths
+#define MF_GetPlayerMenu g_fn_GetPlayerMenu
+#define MF_GetPlayerKeys g_fn_GetPlayerKeys
+#define MF_IsPlayerAlive g_fn_IsPlayerAlive
+#define MF_GetPlayerFrags g_fn_GetPlayerFrags
+#define MF_IsPlayerConnecting g_fn_IsPlayerConnecting
+#define MF_IsPlayerHLTV g_fn_IsPlayerHLTV
+#define MF_GetPlayerArmor g_fn_GetPlayerArmor
+#define MF_GetPlayerHealth g_fn_GetPlayerHealth
+#define MF_AmxExec g_fn_AmxExec
+#define MF_AmxExecv g_fn_AmxExecv
+#define MF_AmxFindPublic g_fn_AmxFindPublic
+#define MF_AmxAllot g_fn_AmxAllot
+#define MF_AmxFindNative g_fn_AmxFindNative
+#define MF_LoadAmxScript g_fn_LoadAmxScript
+#define MF_UnloadAmxScript g_fn_UnloadAmxScript
+#define MF_MergeDefinitionFile g_fn_MergeDefinition_File
+#define amx_ctof g_fn_CellToReal
+#define amx_ftoc g_fn_RealToCell
+#define MF_RegisterSPForwardByName g_fn_RegisterSPForwardByName
+#define MF_RegisterSPForward g_fn_RegisterSPForward
+#define MF_UnregisterSPForward g_fn_UnregisterSPForward
+#define MF_GetPlayerFlags g_fn_GetPlayerFlags
+#define MF_GetPlayerEdict g_fn_GetPlayerEdict
+#define MF_Format g_fn_Format
+
+/*** Memory ***/
+void	*operator new(size_t reportedSize);
+void	*operator new[](size_t reportedSize);
+void	*operator new(size_t reportedSize, const char *sourceFile, int sourceLine);
+void	*operator new[](size_t reportedSize, const char *sourceFile, int sourceLine);
+void	operator delete(void *reportedAddress);
+void	operator delete[](void *reportedAddress);
+
+// Allocation types
+extern	const	unsigned int	m_alloc_unknown;
+extern	const	unsigned int	m_alloc_new;
+extern	const	unsigned int	m_alloc_new_array;
+extern	const	unsigned int	m_alloc_malloc;
+extern	const	unsigned int	m_alloc_calloc;
+extern	const	unsigned int	m_alloc_realloc;
+extern	const	unsigned int	m_alloc_delete;
+extern	const	unsigned int	m_alloc_delete_array;
+extern	const	unsigned int	m_alloc_free;
+
+// To be called before new / delete
+void	Mem_SetOwner(const char *filename, int line, const char *function);
+// Actual allocator
+void *	Mem_Allocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+					const unsigned int allocationType, const size_t reportedSize);
+void *	Mem_Reallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+					const unsigned int reallocationType, const size_t reportedSize, void *reportedAddress);
+void	Mem_Deallocator(const char *sourceFile, const unsigned int sourceLine, const char *sourceFunc,
+					const unsigned int deallocationType, void *reportedAddress);
+
+// memory macros
+#ifndef __FUNCTION__
+#define __FUNCTION__ "??"
+#endif
+
+// call Mem_SetOwner, followed by the actual new operator
+#define	new			(Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? NULL : new
+// call Mem_SetOwner, followed by the actual delete operator
+#define	delete		(Mem_SetOwner(__FILE__,__LINE__,__FUNCTION__),false) ? Mem_SetOwner("",0,"") : delete
+#define	malloc(sz)	Mem_Allocator  (__FILE__,__LINE__,__FUNCTION__,m_alloc_malloc,sz)
+#define	calloc(sz)	Mem_Allocator  (__FILE__,__LINE__,__FUNCTION__,m_alloc_calloc,sz)
+#define	realloc(ptr,sz)	Mem_Reallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_realloc,sz,ptr)
+#define	free(ptr)	Mem_Deallocator(__FILE__,__LINE__,__FUNCTION__,m_alloc_free,ptr)
+
+#endif // #ifndef __AMXXMODULE_H__
diff --git a/dlls/regex/lib_win/pcre.lib b/dlls/regex/lib_win/pcre.lib
new file mode 100755
index 0000000000000000000000000000000000000000..ffaa4a0066eed90aa049de1720c53b4b77ad9c7a
GIT binary patch
literal 120740
zcmeFa31F1fxi@|$lVz9*OacL;#5(AxD2Q2QRc10-$qIz6A|ZqT(U8PsMxX@^ouq~g
zX>DtJYgcV;uie)R+S;0c2Eo>a-rM!I+Sc9+O&6CIL0j|x{hsr_vt>e~z4p7`|LaNK
zGtc{+=R9YB&U2RcoH@&yx|(;~V87NCYw~gzU$?lZD7R>FEI!wGEx0Z(PlKE7N~t=f
zavs*tRo5wXzNfNZspzL0{{G*7mM?Ggc^Y$TJf$`D)y2iNwVvf}UlpF}<?fRD<?agn
zmenmUbOWpbx)RR{pn&#zJ*u&@xvQmdXVWb${-!N$E!_s9xubJWV|&ximaUE5fi2zs
zuGaSL(N6KmZCx!b<0xa1jcu*neuKyM7XJj?>7s*c5A591(iP<)K1?AsBd56=nNeKk
zsi`flDk-h=Y-?(5YuUQI$ltNN2p*Of?QGfE(X~e>-XQl?c&b*^R9AT`Dm;PqTiQEz
zwJ$H~=vrRX+TPsJ)z#7rZylZf)()VzwECHe9%cHi^VF31Dr?KDsyt0y+XFjW+Ckmg
zy}YQs13=UAqUMgBojML(E!zWaW|nvR16%i)TnbAoD(h;B>&ra5I=Z&TM6RgVTfCyG
zuDsZ@rLC#`mRPq+Z)sIUrMK48)YiG9DbB63rosoda6?wcxveN!;q{f5csfzANDym+
zk)Wc=`W2=1)fLsAwvJsbU9oN}YD(%$%WA7U&F%iKwph0+--_az>dH#b_O7PR9dT}T
z#pM-cD^_?q1MSGonDA;#eN`*GH9k+Evok)tx{}(u%Ceej&(_xM%=qYd)~zV5E%z3C
zJx$%st*vox)wPw?)!t%HcV|;`ON`rf#oqdg^0Klj&+hR|7uS{6d+U7_HJ+WV-QB43
z%Zqe#i3+&b=c%kKuCJ`B@t}xz2oY;nS4(G0Q*0cIOFhMvE9y&1%d0%g^HCd6BU;)~
z8#}fwFY0Xa`&+u&V<Lx&TUJ?DR$WqE0uRlT^MT}4c)b<Hp2FpYMazqF^Oi3zX=!d@
z>sh`yKR34^Hi&Z1ii%=yIjR*Z`_3kR^A5I;&ZaKZ+#N05E#0x?6`tCX+LF@R`btmt
zo_2rJZX}_ri>;$+8{#h+1esD&4_OnPOO>9Qy6Wosn$jvyYx`|YZLJ8Txubn+t8PbH
z5>Y_;Ds#u@aiyoW+FP}vy1qEBB+O9Js-&sKgt@{~UQt|ERa?!Z8SS{fZgu5)1l`uu
z%|;2478_6asjI6kEAy6mn67Qxx+x_(LCtJwf}h$o)rPP%#Y>f^0-;n@msNPQlp2>A
zJ}m=~FLld{@{3T5qVuN8Q@f(F-d9pp7l~(_fI%rhOcyaSF<z@ZY!h|$RbJ1|rnYSz
zT@cYomdMI+vCx?u9WuPvmR0#`(A=8aI-+WL5m-ga647tj-3h@5<}tz7B8MS5YU?2F
zkV9R%FvGNF>F9uU>BciyvBFzkR$k-vh&XIQsPNv^g62l~>hC~PYJ((=D<+89VsB|p
zZB+%T6WdKwn^_SHSh2RYpjF-0(zOjzD>lSB4<to-H5!#Cx{?>Qw{$akI>fClEuC#~
zy@D4tqqeNNssf^^9lb!u_V(6y&`0x*rmiOB&G<GD6SB|isVntDNEO$HtBE9UODp6`
zD-x@F=Zf0pMYjf;+WoEDTH^$uuh>&sTZg*BiZZz<)Q2TGJlE8&D6g(5E1R@$RM?tm
z26evL`iknh+KCx#>u5ukqnRwvk9hQXs%z>>s#d^bg3=1KM=Fd+&4|ZRPhCZ6NpZPv
zg~z`OH9=Gm^xRz?flh?6qv<x3GsF~H23vAbd&Fy*r@FeNxUvj2q^o6H3&a^Dzx4a<
zs91|zc0>J;&KY_HWN*Y{xd#HSx}wBa?dfW2N5w1Z2tWi-Mx!%kDYLAi3O(9ud9}B?
zy0pd=1c+lI&v6AE&7i)#uB5!a+)K4h<mf5}8)=HtNrCOoKsO?_1+mjP-m*2q1^P?9
zx4Obt4=(v=yIS>Nxv;u2_H7*<w`^%aXN7k(+-R?LwKZstrDe#q=0I0>D|5KHsSVAm
zxg*d9did=mm#r<^S|c7;c<SoP>Wgb23F4TWQX#AaZEM}#67g7tj-jTww7%9C5$$M8
zJ6qeE{6>#kh87|6NN0M)Z?&h=SL^fER!91jmhR@JPDHu8<<@{M@^EQI`>QRfE2%Fp
ztM!=u0jjMLUQ1gGyAtFv`asFNu*VXgr@R#D^sXrJggY-v9;uMbA@qo??JS-S`i*!j
z_te#tt|+O7M<Ya|DoaO%PF4rj4W*}}%OA;}l1fj-in{vZx)n8^df%$j<waXNNG(Nb
zP_wO7FVE#qoBpYd1YF}Osj2bSmO+7oasr<aidwX?LTi@clA&&DDx@rP)ZMU_FIsE(
zt$kaoIRI$c-O_B}so|SopslU7eOrg|8U>=CYU?n4bo-l{Z)uG3rx7tUMvT=PA6FJG
zEHKBF$rxBZoTJorS1HwB3AkGZnksn`f7VIRjOP>UEAnPBxFxA1f%GqJ4VmurVQ3it
z91r|+Jit+X@tYYBypf?V0{G|f!Bp%2Ieds6(fxDyfEM`A;ln?N5C8ukKD_Da&wma*
z-lCz04>KNbaAMi$$Nt|Kv>1u~`_?@sJ?43%>md`2k>1!U$+p-b)myb_qL+YT25fPw
zK{2DV$&BFi;)Z4%8O_Bl6aKAL!bSP!>fvVlf{k4mrZ;uBY>X^bE$G;Cvx+z%d*Uz>
zi#QyYy99Nuxfp2#GEr>ua&xb{?mCyNAg`d%99vdf($qH!w|GBiQ|cOwGierV<wDVI
zE&5HV`2gly%s1oLo&ma+ErIRs)uu}qXx8I7k)$#F@u-aA1^$-Zev=5l55VCUc;1}?
z`c$Q6Dz|cF)NhXG_Z!gWrokO?qp{-gWPo4S)+T?Gpu|dtU0~3dSWiZ-$KY3H;xYg%
z2VI>(%OnXuosI^Rt{%XKcz#I7wI!ux-Zj+?)s@9dE`{Z*X}HuCgRHAAsrA;BuD;a8
zG5d>n_Tup<OD29)^OB9td$#XtZQr<~V`s}oudl{c9>CP?Mwa9?g$s%{u1Z`p)FL%2
zQ@NB%Ra2E+rKD@SrnR}Nqq}39-!*sDRjxWL>+NiP2j-nzKD|!Yg)m>nGla+8kneK0
zba%QIG;gWyfUxLx%_F=T(~w(NwQT3>^)7cqu4_S8)9My3hOhQFb@_>GY3&r3P4WUB
zBrBwcw}>r*+@eFt%XeMlLb#HbNQTN*Q!`UpkYbD#UzwEIjN-fuSclqbKz6lqhX(~Q
zHj~7`N0a-84kWt+NgIx?Ub8lIs^H9BYfl+2{iUk3Z2#*DKKK5%;7l0bH?-EDCPbqt
ziD-Ygu3+dP)|b#<U;aYDnZ_uO{!2nn27j3r8u_~A<gbQLSqC=G^;jRX|FnO-$9C7f
z@Dfey5?WG*o*X_6+N(AXCSOJ3&EttLk7N9?xjkSfygy7x`v|_?7)a|G`~na?(Lv3S
z5Wqbgq%9-b{UU=qqRjXVRL^w{mdth8PxRZO$#jfEBPQ9wxkCtPuvdQmHt}<sm_L7;
zn8gCl{Q29&E=|lI5*wxJJlOR5*x3HZJU|zmDfn6Nb%%d?bb3<04VRcQu?CMOMN{BC
zIqp3=M*=C#aS&y!-2qO@s4lj?A%E)rqdma%-xRK7&Vzf##>PS=?(|JJ-MHbX4X&)a
zsp?YLe6rLM*mDFbhwT!m7PfZ96rj39aG!+zHi5neTl=shEf)*!YCxDe1izJlW(#yX
zpo;|h0-y^8`Z1tvf#xKcehUCyAUGc&9olL@nqM=ZS>n1I5Sv)4+6QR5;B*rOQ<b8e
zu<b%yB{6VF+?)y<WYi4R4ErM04tut`752sIcG#Dwe}U~%ABTOZ`aEp6dKC8M>ICd7
z)sJ9brOv><TKxs~d}Tvm*QmL$7pOYe*Q&j+bJgcy=cymU&Q}?TU!j@>dx^@1y-ZyM
z`+AiJ`v&EOy<Dw??NLpzz3MjD73!0)SE$dzu2Piif5y{`$29EEh>tc1PH@cUP@MZZ
zA=ExtA_o$>vreGTz%va`G=J@%y`Ju4_*<khq>mv?!#FVxjI}i^FID^&nGEH~{0nNL
z3;g%AwzO?kNhn6Lrk^zRpaD75!v<tmSI=Ai&P@y4d*@ztBXE(R5TFF4eKNu;)XbUt
zR(~MJ^`Ys-haZ{!@*l3bau4DY-w`%7?{saC?Fda3>9*#DxeGeCZc#5T*oK`a@XNTp
zKBm-m%YtYHiut6lu(7jqLF?9(^hPxX8msbb!$yV$xw*^=jfqxnh_zbg(`$^0Rzw(I
ztA(l!p@@lAYOFw8EzEMNGQS`F@E>&MNAqERSS?g(NKIo!(?Df4(nXA<%NnO9B*>j8
z#Zl5tzcgkgu_~8Jvbcd^oTy@H!|h1TJE#`WfJQ~DQjCq&qN|lsHFKYNJd$SVLE%oC
zB-Pm3Ejw}W0z*E6!M>dsjO?t5!N{JOSPXaV#9(C4O$0+IteKf%$zGTU4MLY4H!&Dl
zZH&VBvF?gpIZ>F_ZrK+Uh4FX9Vd%C=6Nrr*+p;bE&XR1g@O60@M_@slreO&Pjaty6
zF)WXWuYp)!S`95DGL=51ISG5d>Dm&dszNgcO+D;ba|>R_?S=b$$C$0%dXG_<v*=vc
z<`)@b4*m1DMjngu^P)x`vt{J*MRX#2j1)vSPNLW}tIb+%(5M6>kAFqB?grf@%o7-T
zNi_0!75H+{cp+RH@mSGYB^r6uAlILOd$yh2NC$o#c|;Wv@f3B}fu_u$V_^wh+=yo*
z@bw1G7v<NUFx)~gI0g3{qZOVn+$Eq{VbDz!?qY=70GdHO_u)xGB}$auDPZsj+#jC`
z4>0Eo_rE}M#-N)h-0zSHx~=cvIflogFnmcc!n*?uu7P^+Md>)sAMOdz{M4YEC|ow1
z=RxyZJb%JtL5dTFdl%z}{_-xP&pcmxzYLo18gvtdy94YV2Td-NpCx!K7^fu)_i`}k
zhx?aiFaqaK?-QW;nL#&ExP{>H8_-;sg?z*_QTejoSHZp1kmKh|Z!>7R4Z4ZKWj^l%
zO%Tr@o{91~1iE|R?xvy$bG~qkL9@!B3x^ve?&!ZB&qjlW?=)=ZF@x|)j?4q_yZ8-{
z%+0Bp>2H2Wj&NVb^C=|q|I$(Ub-6A*Dt~L@&*A@WnPgb>mWLBN%`iUXh=x7!%)>0q
zNn8eLqm8K8vMa=)Y?)JmCk6t+mdPsDjg5DWetC7_HPFqCLFh;{X;({AoAlkvgD!0e
z2pp=!fb8n+fGPyH$$;!C_`8g?A-_9&u*98Qf3xl8@DMhmZ^+sA2&gg2Ozs=H!~Wno
zDEga%k7gVltahibyg4n7_5+|DY;b3+x_L^yInEU(?|{SV&_=hd?`Lb)9Vl^U-QEnI
zSqOEm_2@nGj)YF(HRqYXhQ9CoO0_%N`uO0Uq=8ujN0wX=$mt#OXAP{i;ANd9FfBNe
z6g-yHI}~`XU}!XD_E7N0V;CM^dV5;wfi`#6Xlm%^2R6DhmTq)s-SP3pn<T<FN{pR{
zEY3rfmd2ZgpR?U)9TpsABV;Ltw$#2fv_1^!@}MG+Dg)Lu3?nf$f&n3in-rXOBQI+K
zr>iE|QxyeyhPn;*bj4(6sUg@iW#~Ce{S5Gh>Q}HYQvW6RGXgV|KjZ1eV;YKF#sOMH
z*pSYAUIHBNZffuyaO;V4*MmOItrKn>BuD#CG$>peHz;JB7(Qb?ou0Lk8p|p9n6DL_
z7#fn;0YYv{MJ_lp8NLk&gAyATkwuXqBsYf1#~0}Q9honnzWL$7-_a@We=^>;boj;B
zS>qi$*1GnvU7-K^TZ2!=*h~iYAW0%<rLmf$w(hN6ib<7y6`^Xk%{mmy+8-*}pFHmf
zn@G-Jg=OiB`_dkKmF?gtFt*j!mqHEhoOPkcLq8clofLZY<<Eqk2>#Og^8JlBj)3{5
zqf!Tta(+ddBpHpT$c#%W<``Iwa$%=Q-(*v31hW>lRdIN1mkej+*owzA)CXxe;}UI{
z-wbP^fsA#hE9WdYYobl8yRIBB8g7f@3f~NqvC5Ks6GAC`SrdwUlrr5YdMW9^mYcB}
zfcBtE-;Y>ecXG48qYG0yj!bBciiNCe1ol~CIClZ?3?YIyzJSSuLlzu5!DLHd8@9G$
za>$X%WC(3^9bi7BsSm>@<WL_oAgxB5si7u9qp3wKRYMT2JVj*iQOv&GekqF>^&xu|
zfUK2(GU`E?y(&zVebfPJ#yAU8MdozcJV4r5M7ku&6qXf}@oYsb3>K?flZZ`qn<hv9
zgl*EA#j-rESWG|UIxA7J$Y#r^50b{UOS5F+OG`=yK}VNXY^mtdV!LLc#I<Xd6$>V=
zteCcOWyP#YQ|n<9awwJ#AzfBx5{<!`xTL9->{7DUtQ{<zT`<&lW?g8nJLe(h)B(Rc
z<MtVMg&OWmo|koJa42c%$Y6D5%HBV$)D!uk$2paM{6Mwa6>v0ex=GqICQ(tQ?gKXR
z8f>^H`S#k;sbo2tHh903QK<0F(8fEHfy<uv3+pSPCqk#qCjWhD@~9Xt2!)ITnbsc!
zhm%K=6v8fEI>LbVeiH#5qgtv8h7eW}fF*cRr8ZFUW`lRYPE#(}HcU1$`8U9J@T)*f
zZmxtqRZ&i7s7~0^)h^gG)cas(sgJ^*sqTe6OMM;og);Yck@_~^+2PuDKi*8kK^F5X
zQfV|y9OLs)ocj>or-={7QmHS*xpV4tiqT(Dlzc9MyG`cbbU61Wa5rOP*7ob;YCGf1
z_%c=5k%&inpxBS#{$4>u{|v<mi{I>Z`n#kXBQ67$7FzN(A7vJ2LRq)Bb_DPNVWVyy
zW}n0cnx=jXn~+2Orvd3Y&V;dgBnw|nlcvTl2TBT~0>7!MjIUz2Q+B)nF{K&Zq7C28
zEWIHvOHDugy@(0ZMzS=~XNzW@P6KUchkVlz?spkK-Hr+Ac1%d8ks;7XGr+H=Hu~MS
zOTXK&8tqxJEoX%`9!{Q@b9m5asgGKK3ruO;q#NwfP~l-Knj0G8Gi-=w(f6JRH^h<T
zY}I(cvMF@*MxzgAR_Z3#z(|O(N@Yqx^I`5@0y|CSjBHXyQ!&0{m0ktgA=7xKnzsd*
zWVIdk)Nna$#hYn%7y$W38<qpJm?|Spth+8X;>yJ}-kpsqQjUw_%FzsyvC4@nM^Vnq
zrXgK1!-^O9<o|bd&s60YeO3+KG}vIw2G9T(-60dw9Wo(ZIn3yDhL}cEC+v_fMn9Yl
zX`9XtIbHhV`jx9r(O2-%tf;<tzQHF;v~#+%@=b?r_QeH&6Zgf1B!<b>KVh30H&IhE
z{gCV15){Gzsjisi!gM4qmnOLAMoUOHT0**9%ru#eS5wCergqS4^X3IpyuxXQ$X{1n
zZpI3xm>L}~lNdFfJVH8ogc8dnP0d1ns~4X*6V!}wO!L+)K5=$i%N8@N@rzF!6LB{C
z+IJ0MP-4N`_{AsAYI6pT=FKlY#iv{Ii^NbbK5>M?IB}LeVrGXy7n<-JSxRA}XWU!D
zODQ_V<^s%yFlPeM^Yj!*371l$=IB{PtrlvntXF-Xcy`nHJfzBGwQz>s%)?Y!lA)ig
zX~Co_q|4$0L|%HPA3#h>8J1o&dMBO2##}UFy%w5qO35qYt1s+>Ky*r()v+nnF^sM)
zQ-p^7BIk+=r~Ki<@hN2ttQM{bm?@nSPN})jHAPa&9b@FhwFPaW%amd1l>V#fEWc(-
zSu#QsPAPdsd{IG-nCO&J(T+{2j$w3486~Sl>t&hhKQ=tFdwfc{jA6BK6~atudN`$T
zH-b)=lrF^^d2ux(V!9(>TzzKfI_<}zXi#3p(qJaALK99qxkr5cD%Mxjx)UQ1n|2-N
z=(Ib9hINKB^A9?H^ZW5>r$n||?xKx{#u-j~kGvDZ`do=O^5Tk0#C#+I#-*L1>$JZd
zMH5Lo#F^{~iL_;MkNEmitgooFGuL9%uHzh?c99eosv}&5dHU?9?;D?XN++x3@~Cp3
z9!~pbjL@+%h_rJihrGC|qfK-TCsL<$CU`}RS<0+mLK7}!@{0JnG}c#CO0z&0n^GOa
z=#<VB8g}q(%e}w;;&bCuI!kCwS&0{nf7tG59@0O+Fs03SBQLHaX%n4NhNV;Li;c5U
zpUG2b!YL)Mh_CWkUr{N&0Cce_)iI1tDU~0q<^1&-f($ev+IVQP!zulNMgYT<cH)h^
zxN@aUbV?bPPU(i&I2$Qt?G>7EO35qY>+P|=qEdPh=wef<V`xaW1~|+9s6>nUr{Ja+
z^~X)rYINKV>$n*`O(V#7B{qtyIl_oO-zH|mbgbGIO(qK-30Or%I&r|UEY-Dz1#f6a
zL0;}c!^dWOwZ$nr3jR1JGTWMHM?o8lFxn*8QSdqn^~0e15W6E7dhsOK%Ulio=M9=O
z@|%)y<@agOWuaqzo}DWU>*z!~3X;&hO=lMe!^)IsM?sbiqeRf;LX@3Ai@i$SlrY>w
z2<R+?z?WJ1V9N1K6t4ebEMefGnJC=r;qV^NJb?+<Ycb%qW4~Uam2Ma4eh&A)x`bUM
zy>WZD7r=S;98F`|vUfX<j!m_45_DIBZc`$<sCLM3*p>Bx?t=!c1@BS$B5jd$^>{uR
z&+kpHICHvh=^I{gj%@w!`8(E}*%RM~M7}jEwr>&J$UgAGw|pV^f6sz*czR;u73Y~M
zEpsudaEhv{Z>+6rXe_BLuWZ1M7L86NTB9y9P-!ORx{At%($)1|UnwS<HMxy$QTS{F
zKPBv^ZdHk|!n+FdUD}6Te3)3LfyG33eWSN_15`Op<|Lx7J`%C%M3B>JG(b(0MbzpB
zFrQ&yW)f3VSu04BY!;FA)oWIV$u2O+1Zk!`o5+=GN>^<N$Mr&kPGe1e7ZJOrzM(G6
zZ?-`vNRwX<k)`XszJ@TrD~M{?P+uzXyTFL_l_u7VxS3URO$UjmNq&`y1-UqwC3>~#
zprdOR#XJ)Y`q<>nH(ey&CjV<pEa=6-<d414I`%qI(~am~OSEs5B*`Sr)i^UjX7Lng
zw2p;Yg$l#88gCL8Y5Xd0ZF!`=T^A<Scr&vX3clLAdNovJT{{*LRqGR+$#a>I;jEgv
zH4Wjac0G~a>V~jSuOL>hE?w0SuIR-P99vBo?~CAzy}l}}?(5J?V)5d~j725gidT8x
zUb?C-%xHyyM4k!W%*rYQU%Lj!#jFZPy4paa;o36iqdm){JwBG|YD$FSeiA?AcyV1_
zHL9&G^GbN(mS^mYZj?`=5+Y-^q0EA}JToNeTC~rJ@Nab6O5%+yYY=O_k%f?5g+}fP
z{wmFSL_RecK5MlelTS@-YeH@Abbhsgd1HP!F(*`-ekM6J$)6pnNp>De&%;u|Z>@vL
zOYmV0eb_Q?I*P;?#-i9!C&|*A6?^rgr-n;RBK%Tkqk#$)HdK2!$Hq}azJWE}xn!p&
znN?UeU!$BHjD`()k_SUAh(rm8o;Bi}MU+-*rVIQp#JoDbsv@o%`H(8*nT=ikGcd)=
z@L9gi_&5;fS9W9gs@L2vXF11j&EE}52IP=$%m``K(o9{Fx>({ti>s~7Ti4ok=4$9h
zcXsfoHM}}HU|m-23_c01cbV7OJAz;5p`qZ=Yr(T+&O2X~*B&rZW9~lw;M17V?-d*$
zxWzJ1l{Ap-u>NG(_5MGOeyQN(z-mkISC#_}ZWn1D;G(Q7tYQs*4QBa$t2vV4JU_N4
z_1*`@$FOgM+E>BQK(l4Qmt_5M&(iDtFP`3n#W?zO9_qGmA$Lu9O&^R;SJM@Nz||_Q
z=K6sRU+J7)09Q~s5BV&ThE(UB^P#~Tkq6hD;8SCRUdz05qp5=*WrRXCw!y-*frdQK
zK*iXZlc<9gW55C79k9u}O}`coR9LjTMI(Fz6-gSA6dXz(Oiv4*bM5^q<M;r+IEoG{
zv<6`;8mP|q*uZ>^4UpGn(?GGU!lEIctwI=OEegKs+WQ0<HO4U-tkm&cG>|ndF1ph!
zG0~lt6c^oT*0|^{VsyX8P|p1|VRX}HnX#Q^F=9I_$&BqRYfNmvM?PPR<1=cF#P{xL
z_ad`n<9zqD`-qFm<-4bSN~oeU`tE6;7F<kTOXTlopv&R{HS+pk{=M*JB;a5^1JY?Y
zn9m@LWE{*V@0gT4LZ<(X1z}cTNTS)OY&ktEvR@cnap8lgU1J9<+YWe>`@N~7$#f!_
zuWx9uDrvCT;_ST}{O0`ttsvtOw(8K>z{=Nc^{~fm83UQzWne?mt+d$cS=QKXP#5_5
zcY8=_NJa?7o@Lp}?-LREAREXJo<lqeLQn2L&K*a?=Tbw%h7?8kpdVb8F>nC{<5w*w
zpWFXmL-1jLy8nXU$a3?;#!rtfFychXmLNuXaWO*sK`V9zhn@+ZO>^G)eKaBGp&s}(
zTaxeeqpyvPIS*A~ci!rx;a}RUC!Br!<S2MF<@D#^<nx)$*GyQf$hT!6<6IO4o$zHy
zduK1dEelN`@lTi0kxlqXX~Hk+`i17Serzy3b)doSL36~HlhVW*?B0QFdCz9^YOog%
ztY@`?yKZlG-@y8$Gtbz6(!X9eyHqy2ubzGmSson<eKUYu1`y32NzjaK^(IHNCgqaV
z$mtKpu^Qa!RuOhtnbFbBw8TU=Gbt{*nbx@IN*G@|ofj8|$v<@<%N`Y5iy7ObaBRaZ
zSQ38h^nasxqZ4k($8i4MZNC>3QE|T8ejgCg(Z1XMDPm$W`k-CfZ-TtOe{|R14lkSr
z9hy#t4#!A|4#3QMNzAuKFOKhjqPidd6>!W(C$_@^nP?sES#&)%w`MzgpTovP?khr;
zD(v+ED0_bH!s}aOEJ@bnl$kK8GiRpFwArRivDxf)2QgyO)2B{NPoFl;X(BQ*0Zo^;
z88c?^H!I8e2I7~5CS<XcAT=I5siL)TWhYgIU{jCDQjfu=?vSN^9ftUg<#l+24~R9c
z{-ml^faVKiPc!|N0J=hO6@V@ms2Y%4pn5=;3Df}SQi0Y3nj_FgK+6Q$3}~)ETLCQ*
zXa}Gx1!@Dt^`cbO3Fs<;{D2k;v>VVof%XDgBv20^uRy(kIP;XM`T<=l&_O`lu9d3p
z0(8AVcLU<ePpbMbAeTVT11b{e6re(Zeg~*Ppcep9e@s<>0+c7vSwN83!2Jb~OCTzr
zI)2H3t`?jP5T?vP#}d%FkMBqT%@m#(i~@GcewNE+gGD~pLm7wduotUt*h^&d@=`_Z
z(5pTI+o#wVOVrn3m#IUrYt{E)*QuvquU7vKdxQEd?6)f{6JejsORzs9n;XBN(k%);
zIh*%&)d~A4)eZY;wHx*!)eHNudPwjO3w{{(x7E|IA6A#3mOZ5|h5fX;684bd7sbPB
zyWnpYd<X2uR1fSC^`C-&R`AcmKA~QK{e;T1l20M*r`2NEKT%%TKU0;k|5I&-{advi
z_V3iEVgFt|0Q-;XIP4eIzr%h>{So%dDg`z5Rh0(&FRBPOR(D|AEbCxTv227r)zSq!
zL+ygyEMJsuQ+oj4tWLmgQ%}LZRXqp0OXa3eTQ7pWOL<}MR_}!U4%GvDpSlb7?dn<B
zJ?eSbLG=RcUUd~T-gm17un#B?>;d&L*ay`oV82&=74}`~4D9!-v#>8vGf`t^TP}lr
zv84d^+boM=Ut+ld_Lr4cU_?hs>wf&2CJS|m_$(8FUrtXGhfGz=;WOI(5#Z7UqvxiV
z#<^dK5>1WT99WdV-C}GGWH^j#G=KWnH99heDvTRLG0ybMR25P5Xu~m7)Tn8yN{=3S
z{XMT4D#c{wuFlU}xDZ7jg~?mA2%lBQVXhm8!A7oFn#FnJF!=O5j%Hj~i^uc9j+z)>
zi*s|wVdBGDoEsn3;@tQ+FU}jsC$BJ`b6$LW7Uz%SoIjpsT$~HWaW06@)x`zld=(bN
z$EPqp#}*fjOMB5c&PC%mFC2$il#3Y|J^Z$y+QoeA;6f#is(c)#r=wc>@q~xz^vvo?
zWWc{|k&N5f@QiW0`H}rx5N!?Y+_?uWP=Dt@Ij{GW64HB03EAZn4fd}N*+oML=f0o~
zv8Q!FT4~6xvH-D1cBpIvva8Dgc?8E+N64=70kMa7sOt>KuDF)NUeKYu284NCKzh^i
zY6G&XCO}@H<GLszyYvFr3vL&1gs^W05PNQiI$%I{^)G<fgF4hl4ahDhGO#yys4oFW
z$gX($277addc=V2>idA$uRGK;24q*y0-7thUmK8Jy$I+^!Ts5Q?8*uucZJ~649Ko#
z0=isq7aEXV`X#sE<^e~@t`-BjOmNp5kX=;)x>Rs=24q(^0h%K?o)$sKuGpVZ+i<9E
z1G20AfT)!?RG$Ia)dv8%1otlnWLKX7M9spXK4(C7br?{g;J$4@c6A&OwGD^jh>Vb3
z{R|NG4u@j@Nyx5#4~QCwL%nD~b~OelS8!JJiG=Jb6A*PEhni_Xs6&9LpE%T&24q)7
zfT*cBq!%V+$AdlwavK?s)rcu<2BN*B;ls50`}hW(x*CdhgY$5Gw)1esMb59B;MX{t
z2OBIo$I!<qwSQ6RDqp>`??u2E32f{;?w_Sy3WhcTQGJS3!AI+lhAPru8Acc&K0#uS
z4cwF04L->55A1cP1405*JcubjR4W*QU5IB9o@IDEcuMe8;Hkz_kI&|8^`YV6Q;y(s
zmipi?Ei3VHoM+`KFmoHhVy4PJ^X5g-o0u=q(QAy4-(W??fr{i~k{ib?tfwR1WXs^5
zl!uT-YS8a4eEBntu}RXLkji>63n!Fa=LS5f$^(17K-I9{jweeUg-tP$rB1@;lxnJa
z7IuR`zk{vmE<vtn=qf-f#kDAmtHHb8a-_eIn_?6$#Yv_Jff-O68A>_q65&1@%gp?~
zr5UzM-2!`#3c$Wpy%Y9j@&(+L>a&2aQcuDzfU?F){d3q0)$_0yssDyuqW%PXsd@!A
zga_iZT&2SHC>~woRTsf7Q50WO)inY$NB)dwD<0EOfYsxL64^9407%PUio|$#?W!d1
zUk1&1cNSGdNkLC(>Ii~onB>h^Ekso`jLh8Yv*P$w6l1^-=P;Kq7d$lL3sCbr9Y5Uk
z6&c+!?aSD6XRq8v!VTBiVDME;F-1@BZ^60aw_qIL$ox;ZTm$l`UdilESfYA|HX*%3
zn-D~}ai5Q?wcCaB*Ii96W8Gk@%ecG36}h@X>6?aJ{tg#5o4E8fL&~^@#MRN|3STDV
z(&=zvI(u&SRW4|12n{8Qyvf3^)%X%h$BTLLR&UDHi{-4H+IZfw6JfYP1fnL&L~mHK
z0&lgj#ZoL@_P#1eN@R+;U2`?@%nz&OY1({+dGnic<I_!UjppKmaCRZA>3|p~y-@`~
z%*Is4f*ri>&iSj2xtR^)7l~<P+a7sEe0dFe!&lUX3-L+SO7ej2MoPzR!DUy%tt>^C
zZ!aF7V;C1872MK7i9{3Gg3H{b;TBx01)il_;?@{#M8QYz$^jL79jkIz=PibEsyNh%
zV4&p6U@U@xA}j;8C=7gYP#1;CRWk64V4!r%;4lgU&Ky8SVbD8sco~HOA0A{9#w=P4
zt%$?XFlI5-RmH(-1Ot^;aVTqI^79r`-#}hQFh#(m$6zqrQ5%t$CQaUAD9h5dM`4g-
z9EwL_5N9em5eyV_QKO<T&`E|-lOh->_%dY>g#l+yE|?g^89Bzu6%&)UI3K<!^P?~*
zi<hD?i!f}GDU2}9BBuRNEDdsgcPs{}*dBvf1U?P17{rhhE+%Kh5SWsv80O~{A<iF*
z!eGb<3@e@X6}_>L7~Q_uCr6CgzSy%0O?YD=TSLUx9^_WUL~n-%8R~p=`<iIuHzhN-
zY!zSop&yNJUsUI;78hvPs%at{znLZ)z47}-K;*?OVA@2VB;^3gYT?j==DTwqz{mqt
zMvTk&B~9%4Q|t$=mYIh8l6$WHdc>ERW2DiX4j6R&iRCjD7^~$<!~KCTjQr5_gYA3<
zmNc5rNdv<ljrmO&<09uR+rsahoX{os{@AiGwuW8|ccBTFAoD2Vi-*ufOmqoO13I<@
zjScNuin3y2j7pk%g0Ti%Mb<}Y1bQc?)<=w^pWgf_%*B(ugHQ)*Y#22|eKQvlHZ~$X
zxWT8@zXu;-cHGk1qCC;49WA(cMLT#3akt8K6YLpX<ccxo`L~$<D9RHT?iuY@U&r~k
zbD%3H8MQvqp3w%gUYc2-V9)3`&;olvS8#<UqMGR8p3&IjYE?Z%brtI8M>)WP!7J!I
zLkqTG%|FTzA8&e8?of17qx&h;+oRz11*65WGJ&5bo(^(KE#yEi$|Txr$?p1wNzhR=
z`6fwMIZ3*@Nz$#EB;AdZq-&Za-S$b+?VKcC_ay1|Op@-7Nz(NtqKi_;SVdUAA<(@K
z&qwiC&@Cj|>)Q#sFTwrdT>65L!XtZW6YSw#YS0Lw&?P>nxgK<z4O&XgM0=n&0DrSV
zb5wq(CXC-#K$nRQe+UmvIDSzoD)AY3egT?47<3bby9f?vL6ZwL=K(zF7{VsXmj^*N
z3o65tPzh*e<B8g1Tqa0Z4EH~wwEPYa%|zkuh1(g>bU{^l5KkKRoh1r)Di|z->QuQz
z*kLd~akwvo#>xpgn2EyW{MuB|yuJ*oF-Gedm@P^a?h~MU5R->NkFbk`8&?nJ!1)@l
zrZMeAa)=_gb`o^R3e`LbI;t=qO+=TV9()CKj~KKT_)Ap(27x~gnzhAPuffC9xfA8f
ze$YJ!_a+|znDf=YJ3#YZgKna54}!-%pt-yRJn^LBScgR6z5=>`gZmdt8ERCxapmEH
z+X;h)bTo;|gWcM16VWBezYNrFmr=tfO2=d1cQt7Kh^MHW^%=@#f>Q!rU~miELluk}
zr-UZ1&r>TQhw#u$6fRdMuLR92D^SK&RM+Px4ELHO>`ucN_fNH&-(~ojsQs?0$B8z0
zXeJ65!KpUT9Kth%XQERA?*rYml}ddD4~-SiMB#oPG(R`!CJLAB<G(?3$tn!4@mMf5
zlqjF?0^Kcee+>`K`NF+$HF)8nnJ8Qj911|w4fS=(8Y-|^3B!F1bo=36wodb7yPqh%
z+3PX?kB4TWa3T6sK4@;i6ToA^NH|e?{{*_v!2KR}BrxYo?_tm!Gw3D?7ga?)W6)eI
zBbLOce2#!_1Kcm+C<^9$;a(4#8iQ`4a2J8cI?%iq&tW{t6SSkRg6{Wl|M*6Rdj4>~
z4Votmx{1QQ89e?2G|Mq^t;AzN3r>{JUjtn?+})cP>iNSh2F)siZlZ9%mxGB5(9C@&
z+R^R&*7{GDMB(0mk=O14w6_oFaJS<}>Q$WlvjhL|zi1lMP9*>G;W#o0x+_6<b`o@#
zgYJ?Kn<47oMB%#OR5A&=i$J$y5_H+1d)FlBE(P63CP6nHbPrF0?h4R7ISD!ri~ckT
zx(h*f$vv>5OrrcFzeSUvqng&7h%Q0@b`R)2XV6YmPnV(p_y%bH_)+ZS_!!&e!i4SP
zE1+xoIP|J}bwa}OAg-QX1?L3@jizLMhW;E!$NIM}5nY0G+zz_;7_<|m<4N%QFle^j
zhy5*hlCW%%sJ)ed!SCRn`)PQ938y1LxV50!WYEEzZkKW6j|YI?0h)~aAv^F)6mA|E
zd<gExKEqJYAMS5J^Jjx@qHtdWk1^1^`dLf~{wpVNW+qJUN5J4D+}l1U!O8^9MEzFM
z=kZM^9-4{5-I0l<CD8PKTdCU~!Bms-B$R81Q!oxdC-SB52|HDTpG0!)ZNPu!DNSSA
ziR#NNIDUT;bnKUZJqfytL3ef%bd2B3r(s2zMDcUMy<ie_b3nIxl63w_(9H(F4^D!P
za_y^=pt~A$Kb!;|^G`iPD`FDm3*&e3B<L;x-J(g*WrMD65_Ifmwoig?8R+&;g6=}l
zeJ2rJ0=e-+(EXP|J5f981iu#yn$0Kif|i*`Ui}p=--7$$ACTt!a^pWh^BaS1qHv!_
z!Tk|5KX?)2+gG^5&z+Pg+#h4UJ|)?re$Mp|7>E$veiNj(d4@%G<Dr=-+=Gw@`#>}0
zLW|17ldQHSOm8v-@&{*I)ID$0{O~$qxQ9V=%%BU0tK$c4UYmOSJY&$9IM18>Hu^R&
zSn`IyjpnMmT!Dsd1#k9-EPWdH{m8@r>%NWF-z>lN-$v_0vW>&IBWGm)qXK^G!_gU;
zS7hEc_SV#d$mi@>H`E`rM>6vt5x7offf4pwRNo`1EHsXZk0kOR7Ia=-?puF$yw1-2
z{I|Y->IRsfKduS>BLX)Y$3Lpt<Xtx|nc?;l{{D92vk@jbjsI=qZw|zQDHalq1<RcA
zr}%4kIojqzxV}Hb?B!&)7cNn3>j?NU`I?q_C!8#*bhWS18-7oc_ww+&Ro;uk@5%DM
zCH$Tu?<L{)RC(VTeovG4)!}!WymyD+r^x%d@Vi~!cZJ{6<=q#4pDOQf55G^7_jiQf
zo$_89e$SBim6-n5>CKe)Ri$N6uk`owP#<wxLTyPHVIg95T?CP&5jEI?puJd$;0YG%
zaGFG8aow8Q5-$#KxX^G;rgN;5`Az-*(z7qj^8wNsa~y_IyrH2~vW(|-OeM0kuB0}c
zL(>dQ7!f`*!#t@XgA~5XRlYEnOkzsvs;jZWqH{6oTn)1<W{`-79GHCmuQ_PL%)yI|
z6v&|z=0Ov0Gm!D8Qe0x-<uDDC*cBlbym=<a90RY<sxZ&YxHLi?dx*tlhJzfWVe)oI
zs0DBGzTCk7^Ux5U>0+Mak;h!|t%^D7BwyoDl7cpi{r}kcB4*23!gx`vnK4?b5xzC6
zR+om6=RbwS<aGnRR+Tn{y)8Eot7^RK!$?mUSy>y-vbXvGlTw|kwWUmzDJ05>tgFT0
zKqjV~7+)QPx{0X}OmqhQkDi5c0lx2gPq?Q=;B77K+x<Jbv3Qi8*&lZ3YUym;+1j26
z+q7G-2g9^2-OWv%E#25yot`-m#&&jex9)D_sdU}=>@q!bFo8=r@QXq4p*Vu(wx;fG
zs1KbwZg+>B<?6wvEy@K?9|&VbY1rDbttrsvZ<Je7x*@=AnYEzU+2n8Dp-*C&0QCls
zhq(}p*Mo7irqZZ4k)OvY;rTHMk^hs2%FIMu8xU9AIv(iiZtZAqlpEY9K=Xu|RiJLc
zR(YME@fe<3<ASm_;q6M}kEvlQi@|nFS5rHR0=F`uawSB1QuPs@IMBv`a5EDic*er&
zCIhmoE<jGf-DW^`^?pFyp5;&<G9bHr^vNY{hx#UPgzV}f5S0t=Z3bjl1%S!~x6pv>
zsuEDC;A#xWt{MTA2(H<H>?#0=(`*j4$AIkWy?{97=TILoAjAa_rwb7m1G1~90C9@g
zp?+XMcJ&)TcEO!CAil*J`K&!P%{ImENS`{*nUOhtM%K((7i3>}(d?Xy-*$;>&ZU>R
zFTdi-xmR61Z~iq4uFcKMFDNX!ZsDTEOO`IX{)XkArY+5AF57ps-h4~j&i0PZTf4BK
z@wQ#N_q^lAjW=y-+&r=SJNNFp{f?gf?+W(zz5CAo0|TLhgYS9oUGIDU2k!phhyLZm
z_k84|AN%+xK6&qbpZfIupZV;+KJdBEf8mQ?`tn!4`n9ir<D36>=<tINee2r~f9Jc8
z3=JPS`siaL#~wd^;)(Bl|H-GGe&*y4{{26G_@f{H<flLT&!7L|+2?-wt6x9=oB#Un
zQ>TAB`n%u%;g2u8_|nUN`tzAr&YpYqwZHroce%dR>Gu}<a3g(rMdgaB>YCa*oUXIF
zVa?ig>o>gpe@FUn&{LLiwIc3y%!(CUxy>rh!FV0xEaiC(4#!D5F994UrWv!s?aqnZ
zfj7+^iNY`)@te>cwcsz9K0S+Pcf5c4jl%Ur!2*U67K_6FI71X^dSD3Ugbk2HTqI_C
z0z>+Y^SOiIe}$QWSfr|C*qH)xr@O|bhjErzlVq_Z874V7Swqo)rcOzjGe=piN!BQ1
zvGAKnm`H9%AaMv=OYrU5GHm<10pG28aI^GZ$Nn_-+SrRIPu}4iZ(acIoPmEueqSED
z5!)7S!eI-IYBRP?`~}!o$7aWT$wn@wRGq5Mj$t<g%o*|jlEF<-Z_rAKGRf$1df<OE
z9@a;~{G~B*ggwCb;Mt7lIXo^@KH>p}=}nwT&tICMD4OS@U}f+i4bWje_eR04C>Y=y
zGU;Jsc(aL_n8)98pV;R=#N{kP@!`QSBCtIIF%Pd72<u745h*;RWuf4>zEmhs2B18F
z_`&!Bf%tVKw?^RWPe5}8Vi{g8kQ>mY0?h?<i9quK<p^Y42ED7JYpc?iaqFwSJLNiW
zeTBEafLmVzzNM|H{T9{K-Q3!$^wr_|GH!j{c2gU#4u24w)lmdte1}udcQF=xL&xQR
z%7H)QaSK*ksK5ygX|WC`2Im$~e1whZhg>&MZPP|{<=a|B1x0B36Me=)Uq3=fUq3>~
zt_l|vxpMQaDQRhL*}0{q>ze#rZU}}k*~<$o%>tkJ;?}Z2>Vxc4j_zN~Z=U_B5Ax0_
zUR}oH4jrMD>HB|m#}X_ZX7Fm9zLWloL*8_5FYx#s&coiU14*zmjt-y72|oV1@v_+r
z2XUtMI7Ku}t86!(BIT7VpLeH7tw<BS(k4g#Op&hv(<Hxb@|E$Fgn7Kd2!S#;+C=B^
zwQ+fD`dJSTH)e!=Ngj)OKhbBhymyXbUT!k#3}4yBu!-8%3N5g4%N~E^w#dzJ(nUl_
z7ZD*XJk5w$fuY%qM{bKuE;!ydwAR^s1_*qRp4E58+520-`g3%DniLK0iPQyQJCkJb
zTSF^&+FM5ORlD=f!=N2=e-Ji4L{Gn5iY*l%apNoX<O9<Pu(&l8nxcR45q!phS#)zA
z_DnxukmI9vF!A{9_&z>M6Aquw2_AplWaD?9!FS~TDTCe=?FS#Wr*1m>iif%4qCd|p
z?GSu?Oaow*9S-v%9cFMSM>{@<)ADcyrc}jEN11}jniU{?2OcyIwA4KUQMgdMNtM$m
zxRRSHpI!$9qHysGMB&mc5QR&ZKol;w3Pj=3DNrt;4uJ{*?Gk7wY;BUIVyDQ-5MKFY
zJxwaM%{WP-7GzV^TG&gZN_*rUPOsd^lBt@2_sB=&UO78yrhEwQQSHEcCDfS`M~|GN
z<dx7b#CbmS)gv_fVPCBJU@uX3!uH?{ANmc!zD#bZ^r%k?=3c=(0NW#%?RnJ~0beEe
zE-aBN@I30fz<AXof**#xM6R0k%IRAR<n#U|@_D02{YWT(410lGM7u;js`p5D>{Y)6
zK3_hq_sCgJUNs8Lbs_>i^0B>FMCTGYPsF4CD%@U&eZ6AW;g!=xl9fYXHf##o5<I5i
zR}VCiwyZyGBP~^vqy+Bz+op&h#-T1Tf|xw%m!aMiVJt!-e4#<y2|sa1;v_g;X54W%
z1>=sXDI9lnOo9Vv#vLXzsUv8{9bA*(P@07pP$xblz`SI4DRM&&0@jm4JYq&9ATn#$
zjwU}!L7zEeMfUI7(SqXz%npk!B~98RA$>Y5A-kfeV%v47dkn~~?ghkF>`?a`kX^2y
zWP5hVXS9UuQY+aK9qMt|gzV~vu-V!j>Zb-|SEm56-8*m^mxk<8<0t_fiuH|<U8DzP
zfkRPx5VGTJD=ifq>QV#3-MWA%9~_FZfRJ4k1EQpGs4@exs|G-n84k7HfVA{CYc2Og
z)9Bnmf14aUo3d+-c_J+O-(%ulFmx0hwe6UN-ucpim!u@)MaWDSA?x|jha+SNnJ*$;
zCzPrz#`oY!6)7|*&<@xK1!{v$NrF@DU{kWBN{$^6h-J|)(7R!4W04k_hC{1);tkca
zE9G#IbU72}3Xzjnik!?4W$+3)FX&2<nOSJ}^yL#@Z0*@{x8W6{vs@`hhFl`@^9nim
z<4U<j@iIC7<I04p!d~#8vFV?%O)2rB@rJe+BLz%9&2VpwlLE~h?b}+nL!ieT`V}Vw
z7LIGp3&*v>h2vWDxZ}PSCpa1^4^w!NlbOR!kI5U~^jIib5h0`%5kfdF2{sGeAx(#n
zUFJMk{0{Xl*o5pj{7qK`hq~K<?CMj1SS1{Ct_mT$`X+2v4u@#XgzPv#k6X@&J7GX}
zxvrEIMjtIj$c{(Jk<t8R#ir3QmouW%Lp5rxH}nFoT<;rN7ns(lPpH{+phn$v<I&*R
zT<5`!sOZ77?{L0%HGskTr=5>1TSG2=V}5(+Sffe$YK8Mo_Vms}AEE1*`{VqH<%gDt
z<6i?yoQF18zM9+{Bt_^&|HX2sE0Ny8toIK#tbUrXb`G3^`n7lVQd}Z=`^?ajh-dKZ
zqP-V2R!X=ysuL%6BC-$u5jxII^Nt|Sr*icnra0cVyyw;2t{FYAF5ETEd1$4@8yrg-
zEIIP@-sg3!FXu?~#-jy8U$^1VV&|b-Ed!rml*)U5>Tl(%H~4zfUTg3Vu7aNhU-vpc
zesuV`<f`DW&jpVzoOjeZ0(N_kn;GCd<h6K_IER^J$-kz(HsswM*5E0ZCJesdx$)?k
z5_gWrpQ`iPWWbOUn(&NA)KK04lT!Ex15182-fB1t&UD8etJoooCsoevV*5{(1B1RO
zP!sGg2($zC=LBK_%@T;!QbV&)#u~a25b>#UG9<MioTdrfX9T(%&}RkuFrd#1^f5r6
z7U*6;?1NI({eV6ukklJsh^1gi6Ula12Br_m8C}y<5%5k`0sFA*gnmdQ*lg^9<e--F
z{;=qp4@o0jA_o=SAPsG~dH}8-^$pmi>fc~ji#}GXh5#Q{>=7Q4#&lTvx`#vuTPGUV
zdi4jmZjc`BFwT%9<rLUG(x2_e35`7Mk+uKbikj`6suK2LRSWweIc4qr(r0}@Z2;zj
zYK!2TVShq(!9J|sA((f<{*rnZ?60Z;!M|7Vl&62j!yGdWztg0Nh*0L6*1_oXo;de)
zz@>;3*Mi_+oIADBWJ8iuZ1f~>=hv?^Gw|G&&|SyIl>PZ}XFf8{j3ZOk6p47VeB!Uy
z?c#<1`TBx<EFvKNQHMAJ6L$b%er|qTe*sLK&X}KDkdG-xE%|Riys+5BqnR>sWIxYp
znjSf=iAMt3kOJy8SUl2~M)RyEW(<+$Sx@F=)Wo%R%i>{JX=6p#2LTe&(wdN6RChK<
zhdK+J5DvFPX0c&9RGI<V)igkCQVuoUfbj7dpw9}96_JoW2$0QD9|TCqu1es_isVog
z24q)j0kL5^)Y}aRt4QrwqU+e+-ujM~tuCyPA+<Q(%C)Tn8=-b}yEdwg&8{ZDtEGLb
zt7Dt1v&qlHuT;HnRjF%hM~gmrsv8qO9bJCc#_IX5jcs^p@zmq##IpuZU_OtS+PGeA
zOu!2flH>mPo2*i$!sxtn9<mLv_fua_zVw8r_jtexO$^A@z3(H|?{prjunbV~Ri56T
z23{Pn^_<%mNP7^8gTVLnoSW}YX5S%r|0(C8<C>i?^Zy2%3`R3`Uowte!AUT5-hJf8
z(2=7lV5%h|_vmZr$}rRrhPH;G+rrSd0cm5wGB(@SOxQ^(7q(R<`_kobwiKDjNf*h7
z3xD8h!(=kYQ+L32h(4Jvt($VfjmI=pH4>R*AkB8VFs_}Nehz}BS+ZR?w07%T(p$FT
zgtN{T3`}^b1&^Yc4h7a6k}yeHFCwJ%B0^dhF<A>kSelwexAq&!1!saM#(JgL{4)j%
z4|xXtw?Y@NX;k3%J&X1Q=7fH@ACqcI-BGjuRrxK24xfG?4|c|;1DPn)3JXejpZ~`w
z)`F8^c3JQD3^uHcX1DZ*`@Xs9SQ?{p<IylM4X?To=Y*k~!cb=z;xxficv3~5`kp|K
z!`3EQ6!KJ=eZ4@6aJCGvb7U6o66w5bGI8OMVO6?xRntT}yab&Im2+x;mxK$I)yFg}
z7#fNq)36${Q2E?xAWe4)e|^_8I|1Zf0(X;}St%C9RSJelzl>E&q*8RXG?~>w*A9Kv
ziCHVc3N@mI9UPsaVT%MMqG@+$Sjt`)k+No0Vs`2y?g;54?g-gcdw{dBIJB+<$I)%a
z8Fj9A?sMH5XlnPjZfkAnGTgge*s@9KgqdqlkD~%BX*vAmt(r7COjNqyX>0IY#jcxH
zuM_1^#Lbvn>Tlo4+ow|`gl-7^<g!;U`{~kW{YeL=1&5MGFEwsli8*NA|038q4+#hB
zaG3RNpKrYJD0q)Ik!30@Qcd1qi3<jcV6Xv8H~lMcPnF@~F9liyyIi0)*uM~nb^1Ah
z*jqg-5C@+>7wBiOwXv$V0Z5etN7H0@X_JBF6sT3)=|HhGOD<4-Te#Mi0B4%VOd#%;
zHFheVx5wf2D_tX^YFS*ZG<og-&GtyG)Dy?ut?0hCwKk(#pl)t$c|*!YUi{h0`M7>E
zPTk1MT@0S443r=;@XD#{?64}}BnHvTB8K+^nbn&)t0!*=>B$>HcBq9)vE&@0U=y-K
zF;p_~=TKiWAiInQpTnC22e9ihw2KPMGIYq9oP_K+I9->uL&}+@uBEY=dq9ZMF_MvC
z2G4EHSQmU^tY9oSVjaK;YB+eddT-i;)gT?kB|AL4Gxmm%HEU0iP4H2yZ#WPB9-#Fs
zDmWTLyJesjR|ieAz9?4*eYx*v`;tS?j@p(!>+CxMx}I~_JNq7>-w|uU*y#Ikwa{&r
zfwk~5%lZ<%I1i;d5A}mUSzkQefx({hP?@C+?ER^h(~WpHeOO-&jwGM1A!cY`n`NLZ
z$$FNUrNESzoi4-=yv_-Z%+WWU?7G(AYqV|Wp|wejFf<B!uT6FwSvnk;LnbMw&!Fci
zKm7u1+!GNx%E9MNGOvzt=i|gp(4ZOb2@FSf#tODoMtaG1)1;U{_&3#r($WA?o52k?
zHk)P26boLbj1wlD%d%J&kPgJDGJG1tiyi`UP?IIs255=!65gpkq^fhU|0IwH{{AWu
z^~To(qTcw5K-GZgD^=A4dQ~7!&e4CWOwLh{O;wyjI3v(zKz|WvE1=f}+5w2YPO5r1
z3=IK#S#Xa6dO;w@R}Ws24Q1&<yib*(p;Hc&&XUQknX=wBOQy9hkVSwCWfIG+T0wug
z3=OZ4S&=KHC!DMH1Ai5c?dQ7b-LQS?Uf3lvl&uy$d=-Xdyg=dKU~iBq{I@Gs+$I?~
zZj~=MTV(Qno1B7st4x!2$>e>vw7PdoKHeqECht=mM!#R-`#tpmnF{@o3?e@%r{G?p
zt_J=-wE*^RnF_s6@g(1mt7U?xL}WSLkH<7m!-dACf5c9QO<FoFjdQ0);1E}xql@F*
zAA!5w;FbosAc1>|F&tz#*CcQ^2dAb+ab2A3W}NAlscMau-R)Z&x3%tW*{U~#{tc-e
zH$seijU6856~qq)^9tezgL#GVgUY<Z_(5e};do!;`i8=|g^2vT!no7uainD2+5Eta
ziy;p4j7!CJku&UFC}8P#5*;{fb~J1_dca9Y4>$?gWthpT<d8;5$S%W7Hhzb!)DW^u
zb!9zr$YITd?CNsZ6ebRJl>zA)d^T!5gHK4$;8TR?8GJ%|2A^U;&)^fXt8L&y0pn0N
z8<1U&5v5o`=Lj4jyUdJGz&K=%gOFW)46YP44t1{q+0~Z;QA|11*A2+7h5%7uITXbT
zA-g&Wh{DOCerP~;^*kVoABQ?+Kscoz5UVmy={F$ViJDC>Nu^6A*0~Ke4@aAOg6F0O
z?9>$pOKeG_R|n5k-<}g3{^tI39|EV_ZPXK!2P#sQp737~9I}p1iB=P_qCA9g?GjLG
z0iBL;wMoP1kd2*9bBYK<yR4L^i;6Z?h8@#HQFDsW&lE*%hOr%hI%knIewMf!k7-tz
zK-@3Ih}n$eXLU?J<a$e7Gv*x0EjTDTPD$dZfO{eQ@FJHeM06yr*@tx`CRvXr3F*-!
zA)WPR&}M8kwa)ql!E;Of^J4RV2J=6~$msXcm-UEH2TmfR=i*&wH0823u^CNiWjFTL
zx&WJf&*gwKC8M=QT#ztx7lA5~IbY_Qeip*x&bZ9gTd1kk#%Q49GS?IXOqI?{LOL%A
z>AW;UGGnNzxp=l3`%IB%1t$y6oT6(8*GYz6So*Rv_(i_8xpSbMQ8%nGRW7K1y?4Q_
zV61N}khNyDsTZbW-%H9P%-ndL@JCoqxCM%t6$;?!vcZbiP<p!xork25jExu0L$z~)
z!_NfIrS0+<?Zi;psQg_zu=cXPlXqNUsHE1BNPHRBcdbW#qq@e>MRDT<5F?q;$WRK^
z1I>(JLO^JswDFfJTr4B4d$Gu<RcFc6%@qhdOSFw#K)8?!F4qe5Q9$fNQ$^#SFVMdM
zr|aVoAkF1DKy$_Qc|g<<Qe_#IA~;o+VW~T$$~3fw7}7k!aZy$KWjwS=mWwlNvT$e@
zu`yL<D>9V_1X<8{cp=q#*t67T*x8~(T_{uSvt`EfZ8C(;l^Mt7vYebO+EBMlp!+4>
z8)T&E54Vc@!O1ipBQ9)PrlA(YR*{0|CkE1Vr{-c6SEdt(QpLGbb4iNQTz-(i-MqYr
z;XISTJzjHJ8mGB1&h*QXR7a#$Vmi2OYvY!d#+IF(IL%gnUGP7szCb&OQw8$#;uVqn
zaVk!J{Ei5GM;uWgI8hU$KoEgRUBOY5FyF&++7u<MKw6_9q%{gcc2RO!ksY$JmXKcm
zXO-6L|Af$6!DiKTh~i7gE^05EgF`AdA>2a(n-v-NkQk6%l>=ghcc>}@vdhW}n}b8$
z1e=gu-2$6c-=R7T$gcJQVk2;<{RX7PpIHs9$|eP>Q^<RCZEHg>^quj$<R-_m<fV^w
z&0M#-{uHZC@KH*%X`$=-&IF#{B%<Y}qniqbZaO*}u4IuV+O4iF7Wvx3DlIPAxKOVE
zbZOFaSmi1ieJvNe<*j&3v)BOGCQQS&!FL2AojdWS`ywFCON`k@uB9VPw7WT0FuV2m
z3%VF4!(hK~>qK=tykH)#Mx6iP%gk^kng)yqnCWUuGnZA^U9m!4sJni%N^umRC;JHL
z$v#55c+4EY?of$~rgk2xx8M$6&i8H#SUlX!5vojIz1Dds_e}D%B>z<Bp-#&{&NR=N
zqe+36(bF$IvFXOZ^q$?8n*!<B?U8&SNeT^Xz(=`cr;VNpv?6WHu?4VGWGX&QMwd2`
z<PJr32Ui8b*5fFaSqUD~R2u;0M6_WUWaG&(kg@K%gv>IDpMy1dGSu#<GLZ!|{fS%m
zo_0UJiAy(%0W<Tmk`-CpLfh7*knp-`=7OG+BBbY}2<cKV!#BG+O})0@jPuaDnVh9(
z1G7Tu?6=gqm8+wgNXEdsnZ0GbLxF$CObND4j%+&0n#r6<h3=%kSV|S$YCTA^q?Kq_
zu1@KC&O?b=8gAH0vdtw`>b6ZTMw%jXl6vQBWN&M9nXoR$8!~6E^Y^-VM|qDellW0A
zdD1U6G=JhU;b({85}7F_!t&9L0E67Hw#$_2+$W@SpHRGp#_(_ytx$)aTrImd{Dpe0
zDtMM^?^zjkcrAm~mZZ@cP|l$C4$JtWhhD9Zi=V*B8?kTI|7xf)1FBn-Wx$IYxtIQ;
zD`PMxWB4^&{|3vzPm_M!zafc!@5zHlt&eQg5x~1HktDfp%qBWRlC**p*>I`9=3vWU
ziJ9hR6Nvj|KASZ^UK*KxmV>4slFLn7Zw_FGu&D`C)VRPVTW#;^2yn5%oO;!SBCcWv
z9u81k4t|&+irl%*<Y`5jkXDol>0&UWV#Z!m@BiK1K-@><fnN7r_zCs8Kg^#D0QUk|
z9m)pu0H8IYxuGM&r>5W*DqKs|7JPv}oidSFa2y~nu;Rs4^YOStM?kiA_&M9U1J!V;
zcIV=$z-`kd2R6F105{;-fhQZ(>lgFA&7I*qRLV=STz=cqVP{|H0t|7F*!<Ur4!R#_
zoK~ivNzSkYZsv}h;MvOpuDeQ2Uwynr%jKUIJZlg97BaG=wBR_db_amvxwCtncisSI
zvGcxXjwJb=!M*PJuLo?n;e9?d?XeMShVOtMkwPTViE@iOIi0={ZiGjynMC_aO(M80
zryKkS&%Pc=<K||-km-e*-a&e>%l09$o>DkglR5mQ!QVisW!VzC`fbY=_>-4iAGj=Z
zw<LBIuKn6kA9_s05qM<l`RTq6NEaj3`&4jjQ(#8;4T;D>d8^T6#4ZPAa?ss_SN!zq
zpML#wQ2(&B;l>Jp9~L^i%>@$|A~pup$ACh@8lWu9365=a_U%K@+OyA6>g?+V1j+_b
zsM6CX@D?1q(b>nV^dw3CbR@^N4AbLlP_YvwNhhZ_pU%i3uw7yn^Q|lnH(5LTK8j)s
zK9<B{?%Ag{1*VqLjj1FmwAa0L-d{sMmrTO&?ch6EWl#+*{<PrPq&t!dh6a;81wR{{
z-$!;KmSM)tDLeSGN<2Xq3Y`s=s#l(!JyuQ*-z8l&E>u50*pO@SuSYeq8_Q#us2(V>
zkDYni)|=h~vVml~!21c8*e&w%F8z`uFG0NE=5*d){}_gf>j!$>Bu-y8T2^p;aI0JR
zMYsVnc>y#z0gU4FeelUJ__&YuYlgnyW68nStj>cutcz{#tr+ZPF{kFT@t?jLnJfkP
zIJ!V2t^@`0ML2|#Lf>>h2;gSR%6eQXm$Nc7BDsPr`Ozys4L*vm2$BOSkJw0i?3Et}
z&t?QJH%e<`U|P?<q|$&5rE{7W*&;MfqN~#n<E3xRIk=9287+5@EjaWVwzHa1!mc~G
z8e3Zjbs~btyx(C+1M9{HD#q+51~U39#s-}BXP_$eXAG>f09BvVk1Y~)N%m*@aV`C^
zWZX<&6L^wQI$erj<2d0?d*Owfz)fzrMm@|=&?ZMZMDZLEp1hRM;JN?UeTduN6T$n>
z!|YARkXJp1UKzaG-GkT_{C?g`19#6SIM^#c1L>(|dK<2dWMK8R$iaaMD-t}=aIMvT
zg7xRGuKo(^-bakO#q_&hG3wXpQz%&k)9WU01oMK?B*ujn$zOyQmB9#6JDFk9EfVVC
zs8G{wW~kg{#@6g%WSo7^%%BM02l>W#NQ`ToeZNI~P!DgymFR#BNx^O;cy=RXtvlcg
zfdQ(a)c4GrE%g+vIrZq%9*2ihcrYHyknY31Z+h_TUz~mK1@1u`EHYqFOOIhgDFSEH
z!TpO6<jVlgop%fuL|V|N%?%y9C-|#0>yhEJ*1>Nk_rPoDso*cuzG^x7+`u&Z<A}nt
zzM=kU{;SOPurk?sD1Aw2INqD#$(9N)Zd~x_Dqni`_WMTLf{(o}^3DiHxFfKyTTcFJ
z;GhI(ggb!L+D|-SL15P!X~efa&O^%<n{f<11&;{F^pHv>_9OkNV-Ob%GTfg8$8K`=
zy>?D|H*^BdzE=RF!<=hz_KBF(7gu@^*POl~*z^6@Mt6b(4Q|(nb%w8h1~ZY}A^Odz
z{ttK9lYBAqay@*zNbeXPu}=4mSS>NWj=`67N(jT~J&(VFcp1_K{>V4vol91ZBZ--S
zq|oquke=hZY~c`-BL8(G)<wR-huu=3N9Vov9hZW5N>4lUOux-j6Zo^4tl&{(n(ox|
z$ypSIg}%^h`cBPn3WJwFL-HunG?11W9XxWk_hZvgZ5|eRJlNpQWj$RMRsc?g($Hfr
z9T9z}?=#T-M&}||a+xcm7XjknnKD>o(g_iRE`8BrC^XLA&%+O(MS%=tQZ?e}K|P+2
z+FOYCT=b-ifXglzT6)fT_fWwZIMl<l8_%+e%c1MDHMFsFpBI=(^@qW8JgYn6k<km5
zEe|-5sk^2AppBNe{qQmuoU?nDFAY@OYz-Z&$Be9=gg{}tgGa5Qr$R^P4Ubr=htJyj
zy_SI|u09d^QU8jhexC&l3P-Fr^j9Sz<8shZgPgfM;Osd!-PzZRpq+=R#;VZKEd41R
zkRDf{85MMq1@$;9^z7{ynKh(xF7^eukihkhCmkn1NbStcg!dhH_I6MSftqSP(nm#h
zuCp%)=5!678w+es&g!?KUAcVyR^RF8(9OJFXJJ_)%=*#8J?CZwE_5EMvwUj`GXrcH
z4;_KgkN2FL>I^<BQ9b^x>Ej4a??L$m&!Itm9B#?kQ335jK$4a~Hhyx)0#_%`igI2L
zXU4hbNKXF@U+9_PS8e?>`l~F#qe-K)C5r;nmOdLu;k)DYa?5BcBWm&KH1C@=fJpW`
zlCzkofnlaBl^h#TT~PV_muYuW`{psja+5Ctkq)QI(mw-ynJ4tfD}H;<Ep+zQ3$V!9
zTQ0y7XYUOHRCiD7IalVN(sQod*_X#^{=~eez*7nUS&Z7W8ILP4JM>C;N5o4#H{1|-
zG4z9ZKSZ8xE;z%eE&ZXhkK^>EPX-)1hfjY4As_=$yxC|xl<6Z@bw~cUSTjYsBMI)%
z$jZS^OTC`ZN6jll-EyNw`Ff62_GcjI?9sAsp%O&-C~;@6thXKsS61;N<WdupJtL~x
zgUaF>L5LoU!agdzWrJ}p>jrP{&BY5PQZ6g!=#Jp4mfJTVo;xrtmx15HzBBu5_??gN
z3+cEF9^EUD+8kiBL*GYcpH2$B2ElP6_)F`{_k&fA_2-qyxSYVx83=hZTgbof`0X}b
zP^i%dnMrVQ3Gwdj;O9=R>@RUQk_XBR!{^IJtku50lL35VipKiHyc4)$7;TU>y)pCy
zU6VpjN=#0h@%X-u2e?UGej)7le1UP1IGl9$vINkik9a~a&wIgKFTt8%a>2>bq<PPv
zLHk0F51+I3JJ7^YiTY0V*IN3^k^(1AQ%6UnHzzM=bowo)cN2j$Miuv?nr0Cqp3cU3
zQS!A&&S;I<Qh=I~oJZ6W)QUh_aslB5$wmEEl*S@o=xN<hBy2KB#W;!Cs1vV~&9q4V
zO26%2jX2a(Ox3T%jKWHkY=y2_4epI_su)Qs8}V6hfEy$f#1$)+!4Ju)?=Pk(t4CV<
zD=5k&tIWQ++TAv#VlK!^sIFsd$3>>ozk2~)gE8h=&gzdU;&%4EgmIRj2WlYthJ!=T
z2G8a>@BA5RZtT$3^m~=Fcgc$pR#&0RVn_&KfFU5nifV+&kWPOM%qiYi5z7gafcvXs
z{l4UWUkXxJfrMr}2nm5n7-RrtT*m3!;l+9A@qzt7t6p?rJIx4+26igfjBL-jtNgPE
zG2SU1%<4hR86eUC^k7N-(}B}VN1VMJs+5KvrxU6NgY2(j;E0Z!;hxSQb4JdKH;MA=
zNVs5%P0a6z5$>gG*&P2x9D)AWr1F_mBPOQA#C+4ll$n@M0W)G{lg#iH3<*!?p&D%6
zHuhN0mCt`l2a|gSOT14rNIGlBz^UuG#lZRAW^@V6aa2C?iJmo>f^UDqF<s{D^Fd%?
zG$zfbHmel*J2&)wvIVqkV2vv6dG!Xq23`)W%?>>_Z@8lGBnrZV43Rlm=X>@cNOZQ8
zI36_HWx-<@{=WQKf6DBk;E%^Jh@ZQ6vDqJbDPrbYUqHpoLEV}gx;5Ja<pOVeA0AyO
z93Z=T_F9sZv-gWOFg8>zc-#y5MD6!S&aXVZYNd5Jyr_Wai<Ui$a<7=}EMs6Ak}t7&
zeHbIR(1{Rb$>8oJ2sJHCMoO^cXtahg59gYMM{Zf@Nxj|RK(6yW>8Jpx5mliKa$TJ~
zKuxFO*GO=51>t4#*mY-Hc7wC;*MOaeo;I7=ZsaI34^s$Np*ghyUgn>M@q8GImO-ul
z&+}dkr!>27$jsc^7oz-fK#!CyTMLC_RXEYe*I7m=*4;UwitN&*r@=mF@4vIijhPSd
z&RM!5+d0^shOC4hRd76b_J)CL2kI=&-X0`l#458urr6M82-60XL^9XEFX;!*nasM}
zju)1$a2@D!JKwYJ_s}<4OIEndru~)Q88wTI@aquovZ$@l0FmCo^aF#{6-Iq6RoW?V
z3VIJFq0n<eJ2Wa`Sq7`aXpWhMo{Z2lTI^{8x>9ZZIwr)qA;dCJkpww^sX4SN7!&H?
zqsbgPd;(OgY@C=Fu`Ug@XM~=f_a9Q4*sdspgR6)8eIg$rMNM`3*Q3}Gc?NO<m2?@N
zoI&t#_HIX(N&D+Lx5R%FcFdOsPhS%}SH&{k<&9lshmU2W*Mw}r<Cal3f09No=1=nI
zEdJO=ogv%)<5X}*Q;6^!uxZhR7LpVA1WO$6j+b6}`mz@gkq}$S=D>}i#|uuJ8BX&f
zHO_&jeLcTQ)59E}bRGv~#`J&%UES#^95Qkc3PHfR(`vUr_@V_<qky0+WBL=-%#{2u
z{WeZ6k6v_UB*WSJJm!B{=P9m7(}Kg*@LU0<2)0oz3WkE`%A6k?>UV^0o{LD-S6p^9
zc+Lm@+5RcPb0z$CWHd!86RP;5;A2ewtXhfT#_m;!Uhd#QcRw6ft^&^?0QGB;d-Lm&
z2U`cL-JL7pu@~r7!RONIR~p5e%Sw;|X$iql5gaQI6c!9YiR;D^*XpE!^cmKl_ME#R
z@Ow<hIp6zvkOj|L0+|nS+~OEUB03Sly`wfHq!YpH4UTbWQiw+C!7qm=)kyXZ1giFB
z2FJ?$=?DUodt=@})u=c4>g$2|eM5U^fysQ*QR~C63>HT(1thb&VGPFkd(-=l?@M<)
zhMopN_8s4wj9)5u_0o(=+*uS7&OSR+L_NUhFgKh=LyMj|Tf34q{ZRyntjSr4s^>Ry
zBm>>q;1M{49)IO0!E+gb0<y+@#m2x)nKN^eDdsBJ5nITYVIYz+e+Jy|PYG^5lb0Dh
zmwY=^ovHiM@R<qnV}9^lCbI>eB%Ah91uS`ppOVgd9C9Qy%%<$4E(bkbIv%JVW`lY^
zSd-)bN8OvpM^U8l|9#CQnE@wY)TpSVMC8<9ID!cp4GAC!0Ro}|;R=T$Aem8AKro35
z8MC6|eW9x>-tLNsH#d0WwRnR!F{q%3pssx1&(l4VWWu_~_xt<fH?P-x<}=mR)m7Ei
z)pa}vEuy8wqxdq`B!xZiCEijLn_NsLsyt9+4818z!;HaeYqb>?({w5=J@%cXLbME4
zS?M3=uw1-9a(v~!QPE5`EQ_M8<qf6l#N4CwI%!@D&ob&R=2w<>QdtwZjAi{^Oo65m
zR=KZj^e`D$^EyQoEmSp60|U|e`VvX>l*ad9Z_GO1NV*MkyxTxd-;-0lwVm*sZaQ5l
zl3plXy8Vp81;2`D-rQrzK>UhiWIpX79I85*`eY$}4n_193WikvY9cZeJu1i}OE$X2
zo0T*^PAaIIKyn-y8C+fYtIP&uCuHC})Vhj(51!GU=Fa=NUfNnWWgSUSVnhRynxs&F
zu*8kcl6UyX;0E^$;RNrGCm~bU%!TKgZuX^(hH6W`c3%T>BhQj%_25?oRAoKq=BTsx
zJTFR>i}MsePWU2=(B+V_MTd`B)X|eM;-G8{Xj5LWZV7a)tj({47!jZT5Ji3$nf1~h
zgl?qwq+e>q74@(D(`9|4>J`Q;lBKVk2_209Q{%*4b>jMec!_S5C)lXp*fimlO%kqu
zplRe=n?{Z`iL5j1Ch_Ygb8DNNQa40G8s}X%b=<6}@V!U75Kn67zxxFL{l_GVg}Qz)
z=u3|5PY!7GKP5Go*643D8ZdY!|DSz=lFOjwUB#6n6Lf+;e~N^rdWZBUEf|Q&DEN;*
zDgW8WOi8hlW7-5b8t4=BGqh5vSif$^zDYy!t90#VWq$!><3Gc=n8xZd*$$EI=nUf<
z7+Xi2@iVNOvVX$dP5py;7u-r1LU6EGG(D5cxnWfd@}JeC_rf+QyO_z$3!3uQ76`>C
z+X-{STD6RawS~E1y^z~**{d*FzVI7w!=6^wm&Ln7HCNq{I&j(01S@7?$vroZRcbfS
zU&GvZRz{p<!$jCL!x#gT#k&mSJ=jBfjjgZ;mG$Ptt$K7YmExB2ADMA>#1Z%p(xV+=
zcj*~jVYe&mpI{?lw`kZUF!ziq*bN$XJ?uJV_rR`E_BYto%2vS^DSHDZQW$>Y6Ii9P
zov``JEF_j(mH`tfDZg<H>@sB?VV5ZD23x8u7xucceAu(f3SeuL^?|Kc)(`fYvVpKw
z%1U6bDl3KEqiiJX4P~QXYn6?K-L32k*h|W`!(LXl1GZk-PS^%zyJ6Dx(PCknl>G)<
zu1utEWZ;Hi0&In{RM;cRTEL!CmJWMDSqAJ$WtlLMB*%mv>~G4#u*a3j-0@Lm?O_pR
zV_^>{n+UsC*%X*OL4IQzY?-o|u=|xoV1HFM8+M<vIj{<47lE!h;<&W;@%$GL&4v-i
zNTp#MYn%agK}AKLy+46PDwEJx#WVY>jh{1(RfG>xMZdwum+)aK{XbD9_9m%KgQ>>B
zT<cP`?A5_9d*RvsFqo?{d(%}NB-`JQkf=T-ml$I;{sfIVAG}6u_a>FIztwn`klT$d
z;GM>Y;NOj7=@Zr)9l(u-_)dJuC<0$G&II2xs=-f;`@k=Zhrut6zk}P27r}btRd9##
z4!FnI2L5b(2L5h*3GO#`f~F~Ju$FlcXq$(Ej@btEn-_p7=4>#{ybKJQPk=4Vjo^Oc
z9WdQ|4{U9I10H4m2p(e|PHz=9W%u_uGY8Bvi^2BhFtCF;66|b_1y3~32eZv;FvpbD
zk#6Q2U{CW1)?9MUwqTw)8O%3lf~T3!fd%Gzu+Ti1sa+rQ2(ZZP4E8e@f&I<J;F;z<
z;1KhEaD@3RIKg}ioMiq3oMC<dM$ON`*=8y|>Krp2oM*NJ7n*&+2hB;~L*`8I5py2+
zsCftYH}kLHa&s9t-+T;w$$S%h+58xM)vO0!Gh3v})0qx#HZ#C2=E-24*&Ezp7J=WI
z1HkXi(V%5b2DAP1!Jo`(aIaab;df~G3*bLZ@r}0M{0KCxZJ=d+24?$z1p`))cR<hz
zfi0}Vz+TodV4l?$%(ukfYqozlm}{H^7FeUf)2$0Nd_LIUS`40PJqQl4o&^V5&x0k_
zdT@xf5iGUd0Eb&!z!BE_;JMbP;5pWp;Arc6aDw#{SZ?hDCs{t;M;BNv!3rxIyxhtK
z=UVyTJgX0Qh1CySV3mNC)^M=OItRSUngGVEX<)5&8MxTG1-#C>9lYLJ4&GtC2)<yg
z17Eb>2G>|0f$OYa!1t`*!EdZU5bYGJ4fvDQ0X)a<3YOVDzztR}@D-~NeB0^={=+&4
z++vLe-?PSnTdniK&#cS9&#h{3k98e*j(sawX5R%G_9LKa|4qZ6*6<g=p#3g*i2Vt8
znEf?)jQtJR&i(=HZ2toGutl${r|k#Nv4dcloeuW4j{y7HVX&Xw3G8oYgJ;^k!E@|B
zV42+?oM=x3=h>HlSK3#AF?%ssYhMTc*}faR#(oIA#eNFB(|#6QYQG5HZEpY{v|j=r
zu|EeNwReM$+i8pup0$JEi}oSlD*FU*jhzRswNC?IvJ1hN?IGZ6_HgiBdm6aKz6gBZ
zUIcz%-voYS{|)@uei__mzXR6UAA$Aux8TpV!{*E$y9Kz{J_h{N?hgKD4+1S`1n6_l
z1O1Mea8Ge2gQ?C%V45Qa+yhP(7<8@%Gn_lX!<~D;N%n)_6#G$ds{JH*fxQNtW^V*9
zwBH4%+aG{4>`%d&_E+FV_I9ws-T_AJ-@&Mz#+c}0`)KfZryY2Lb0XN@=?!*r`hlID
zp<owhEO?@GDcIAw4J>y44i0d(fP<Wmz`@Qx!BQu{=xVqV0!KMVgJn)faGcW{oZ^Vx
z{|g+k`Zdk@6L_I>4LHkL3`U&4fKlfm@KWb-aIW(_IL}!FUg^96Ryyy1S2^3k8s{f4
z=KKO)<D@WxyUr1_VK+L5gEu)xgSR@zf_FHlgLgV3!MmIZV6HJ4yw{luX8Y%X4?2Ga
zA8~F5A9L;p|K=<Qmphxm70x%{Q_gqbDrYCS!O38xxZF7ueA?*%u651=UvkESFFRL)
zuQ-1KUv;hpFZVqJ&htG6Ug28@&iB0vUg>)i-0XY|zU^!S-*vtRw>UvYo$omZgC98A
z;73j|_^~6>6CXHZ!L3dN{MuOv?r;`^-#T}I-#Jf%-#hEUZ2x=U&(6o7>DvifzEno1
zA>V0WD_>vmNM96e>zfT``K|@C{r7^MeSZZ{@~sEE`aTD9e05-V-%hZH?`N>5?{_fQ
z=R1V{*%ty&@f`}D<U0;5@U;Wa@|^+>_7#Fde8u2U-`U_fzOmrBzM0@C-&Nok-wogt
z-#y?A-y`5fz9+%izNf$|eXGD4-#W0?w-vnIH<0o5{l4MggTAxDM}1?#$9?C6fA>{@
z&-$(fH~ChAJAE&Ln|<rRw|twxcYLpc@A}>W-}8M0ZuNZvZt;DkA>V1pUT~XFrZr#s
zQo-H67T{jr(cnLQCxSlz2=E~P7%<&G8Eoyp3d}V`^zvZ;t>6*<N5CWf%fT%FOJF<y
zX0W~gZLov?Gceo#6WGO{!W<#j2!bd2Lm;Csu)AMYH+%RygQxpTz`p*GV1NHaaDaar
zIM6>69ORFJCH~pqF#lX|q`wM0*MBW|p8rO$%>NKL&i@EF)&F;Jn*RgvLjMkMzW+yX
zf&ZW2RsQhd5}pNq=<fo4?9T?b`Fnw%`p*JC_YVcX^p6C;_Rj*p^GB4=Q9cj+!GACK
zqyI^8pZ_`V7yrlLxyE+zJmV*Dl<_+_+GxSdWQ@@o^rsvTUTd5RUS|}5+l;foPmRIg
zcg862N#9t|Nx1;@r(6jRGZ%uTW(`<l-UP<XTfj2wui#i~8F-}gB-qAz3Y_7r17|uL
zz`LEd!F!x{!DpS%z~`K=!B3st;AhT0@L->xSw)5~2p;9j1dsL|1upls1)ub_2Y>O&
zY{{R(0I-?Dw)nMQLU<P6_-6t{;<n{GjB7MLzLZgOfgY9dJ$-P}@c^UV9;%c?895#}
zz;Q=j%Y5WIz5^UjR(nbo!j?SCxl+p))9-qp2{SI7Idxk3{|kMmB<<}#{(DG+>90Y9
z@v$_ptgs($sG2HE=k!cg-p)z34ta7;vMoqdrjpgLb8?$lnJhlN|G=U?nCD4Y9~(G$
zP*K^i{)74sEYf_OURYX`oSAMp$r|9@l1<T`+%4Jg?8)7l>4bMnHZx0{W-0e-lHs96
zB}J!~CRI+iUdcM@-FhXb(>*&IrQ$>}2M;eT8D1JMsF!L+!*M(U;!o=U*XrIYS&zL(
zcCzwXkFLr3@IAUF--sT~47&9=Iay=B$H`5~o;C2~9y!fYZl);LgS(U2P?ABz&pM-M
zXi=ZCzC#BOFTsXRq7M3<KBy0Od1#S%3F|+2P*Sbp)uvfUa;^60)vWBz>!;b>>Cx=&
z^yKa|ZSXy_lWVMJGfOr-F{CWUho!UeOt0gKsY3LE5*F?_=4o$Npt|Mi0T%Mmi(+70
zr%3vMMh5fbT!sUN7|ko6HEV`i(L0Pl-XRV4+{K)`Bp?}}L(v1X$}frsi?QP{!387|
zR~QSnl5SG;G$u@>xWQH*v3%S`{)$&F&GW;AgvoOR-AmP7Y(ca+1V%V>0{1o8YMJ-%
zvhrCo)Ig9LmY1@v;)p1%$;py6G1y$?#db}dl|?R{S&l)<V5@h$@X52v%O_r1HXRRE
zo}VwRrp1ZVv_zWJ@`kXo3F9itu>*w4Q?S+JUij4M7(cv7Pv6uK_2O}}F4eH5URYz>
zg7Xt$Zq5!Txy@dfm$P`TM2T}IhopA2W)31?8Ua$`_>EZNo$HlWoUO^-yw?k+C0smi
zTC`km+SN&MQ8&vV?m{oPp=zZXZ}&o_(!IOPB3!W5Ixk!mbt=ju4QI)9BOI0d&YV?#
z@zfd73dUZ+R<pfRrk7717b!1u?|qm9H+u)rfU794sF-?jd08V{V3N0ZbyZw2b*9|)
z3LfW%TkQIF6B~!FK}WgRdtRCq(eVvglUh!+DRl@3;LL5D+nS$CWbl&sy^==$YC}@-
z8jvf*^E7P+&SlHoLh*ubI51JGHJ&JD6lP4CL``97t09hPkI6alx|ymiM)D}t$8DQ7
z6<-{3M!b^b4EY~FLsFDSDt<gVT|%VM$P*x`R7{)U21pcXG^)=g&&};#$t0k8P9%*c
zr$|7&f$Q_sH0Sb2NUr1(RLQjR28}FP`E>P-g}M61!m!H0<1MT1Smp3o!0_>3*589_
zrBzr!&F;uvKv35-g$0bZpzI0+)$EQi*JP&bOSmR8g$0b$!8bLm$YTLDcqIEFLAC5E
zEMS}m%4&7cDDxPO;b1a$!_1$@0%|W;R=R_%%(-jc0pmuPtfmKzTRj%g)nQpV4;l}H
z!UDRVAuH!W-KP*1(3NyKKgik~Ghhw-1YD<KpLs06TARCa9yDx5i?W6uFj~Q6T|H<V
z;xXz4CM)OEi^tHzhRM1*de|OA4;v<{?&x8A3_WbvdJP-xG4!xuvYw9~w#U%JhP|j^
z3p|FCI+*Mp;H1uD0po7iY7LXsU||76Bvn^w*i#-080%rrYuHO3!*Lz#ISs4xSitxd
zCVLe@W534&MoZh>6$l!wJQiS8%iRkI8f`rmFuKB4=(*iJ7BC87vOf@HUCU(wV>nFq
z8-lE9xh!BzhRKdXko6ju1&m8!vZD|*=6Wo^I+vk)3qjVmToy3yfXOaHkhLwB1&qgF
zk7<~!UkeMcdWF$g4SUUF)B#NPC4#I^xh%lyl)K{*WL3&#0al&dy^5gG(qrr~z+{I4
z9es}lSPgRbDuPB=j|Gg=V6tlwGzvWyFowYH(=gFn6BaNgz+@LBXiWAPW@cfsAA++&
zj|GfB!DLS;$oh`U0vL~^W1l`b+<|x4^odg=j911@3+vk>Oh^O|juqhxdBubyQ^rjX
zM=rrKq<VLxulIaSUR)lQZiVQWX$Vi7F=HksA$dzqojx^EKJ8MXO~SXr^a&&}Bg}if
zOZn`n6_N7kkuWcTxPe<qSh~B3?zJnzQ^t{QWJ-Csf>1paw@x{3k{HZwe_CO9YDM_e
z@W~9?r%vZJI(4Gt*ewHx+h=zmT&(9(ARRWH5{^zUpFOi2gS!*Mo~hO8Ga^%@{AA4w
zp>&hWn_0M&myv6!*L^?6ujrar4p)?46xAYP3^O@ubovF;XIwHpTrzlA|B+!m-7Sw7
zfaTwD5y=C6{e@IZMR*+5O~$Anwew4d?M8JgNK?QPu*6El2+x>4?b7fiQ>8TFaqd;<
zxLGJ;EO<P>X`abhx67~G5mrHqROB(TVFQQ7ju?)hOx6hGJ+ht`_ezL+v_P_B;D$oe
zi2cN|48GwFg_dzPawTC&8_ArE+EGCfToxUT+}LK6jPl+j-l#}R#Lfz{QV?#Izlhxo
zMC|6!4R#T_GlrWIGU;nAJ&M4ZsP}aqLMkP-C_#vBN&Axc-z@nXDG@QS(zsS+Ry9&x
z?~w^Eo;g3aHxlbeIU&bXLdG*<yXyN_i$s2#Ifv%`5NTKa?OZGN9r@0nWcv}E%cy>9
zj+{{<!d5ZSA1Fb{9E`o0^X|`Ua7MR3;;VdZf4vo~tKN?c%c#f+9PT!xgzRsZ!mEDh
zoIaE+?8<ES6)Eb>g@+N6KL4~iu~(ucBJb3@=53KCA7FOeyl|KlS9EtfBSP3$WOwRT
zQP(ILt&}9=;wz;nB3mRT8SH~`okb=xDV6KOYddYKy*Eo@BEN<O22l;PVn4V#4<%-&
z4HWtHD?aDUECkdy)x6ztGrXHfD~p<nNpiX50pU0<pSL>FV*Y6zqA7Bt76wHPtw63v
zrIjucHGzyps`ym4$U->A6TXp5JjeB=6=kr^CJRNvWTX5mzJA?M|6JKtko^w6CasSp
zQcP4xcf|@LUC_~BOSR_PnoU!d@pK8KjWHR16n2lrbJ}b$ODzhvQ_l~b*~k<VTkn89
z)h|OXi&nCL^95L}_6+;!(51h+(iyB4y_sW@lTx)CGF%Ouj8L0Eqtyt?ICX$BfsH_x
z>(ruRlr2EnP`wnqOU;=q)uF}Ry5WD1nnx?w&UKQ$J|^o6=w998zC>T3m+5Q%a^0St
ztJ||z7$1{b6&rgzHEg`mY>jmAYU5z=TH`SAI^#(2dL0}rF;0fxVB~`L8uZr97P@3}
zH%xdo-}vWLh{R>3+h~_`{7?MvtVhL&2z8uvT();Rcne*uL+P+3%x^q>IiBS$bjfwT
zqa?}4lNY*jlI;6Pp5<IA)oezi-Y34$HLHAb`D`6%OCe-}86WN^{FzDEw24zMbSI~>
z>?ZT<CKGB&H+e!Wv*)A<walHHOsEs{W)AQYyI_1dU8y@)2oogPX_)57L?cT=xq4zA
z6QA_8_YNe@zB?1#boMQE>&?DpBE6fgDNKSDk#Vzd&*s^9lNr?xjz|XFS8w8iI^o#H
zF&Wy+)nz6iiApLuCzWJ1pNW&>QzbdF)4L$EK|J;`^_vl$9?_}wcJGMH!{Q5&GU5Be
z%Sb~OS`xaK&@;%w_z67ZuFF4p_}!U>Fn4AlEYPTK!z?nC&ypdByvgN-r{*ccOnGot
zZj36_FoqU0F5!jEd#&NNG@MGoWZ&8~yMtACvcYbHUVRwdcDk4v$`qr!8E4ZmXEfH8
zukC9;!-;Npjx?uOu{*x9ZeX$%!ODGMnb<J4e*3fG!MBIj_m31+?mJzq5Ee)BD);q`
z^r+m|j@QM$6QYOi@jH=L2$lw;PW8u;F7)1F5DiryOcd<1B5n5gt>`x*bNgj|Iu_jG
zV)_XFM&8C)$YisoFQ#?ppVm86HHvC&Fs;^s9DK+(LuF2WAVV33p!*owx_a&C<C?05
zkAm!Uu*Yxo16$Jli7Dxk;KAyxt&MuII$C8}j#oE09n}PRmT@<64pC#s?Nn;4y|Iyy
z4#sO>N9{m<g5AqE{(0RaTJ?=MjnI$`zS<~E=-GTjURQ)*g|S)!`NYqE5gs>^%C@)W
zBKdgSNUEIkq#Wea`26_4UG5<a(1zGwZ1_l?CBBsEviOO-0V>MGbvfhRiTW^U5jd<5
zQ^FP~q4Azc)?%a^it_cISn+1B50NCR;TUUV5Uk<x=R@wC`+Nv<pATUOBJhdVsAHsS
z-rU&Io?A$J&KRL>nf9A7#`oVe-|msF(tMHAE{>ca&G$HIzQ}Q(fbjah^vH2uqt#aY
zWA(?;@9RUuo0#VMB&ns&YSL1rYjs=deAs?Um7(a?xFy133=56{Q*@supu>Qmn)+#>
z#-LiNL7dj?V2RP0iQqBnnJh~O21jVyJw^ux2WzVh^Qx2q!`)z8<9;yffGu?yN8}@S
zEdCK5Z>fLv0^`S}rN+(qN=v;h>A191zxUFVmMXcBPyBp29yf|7Vb{w+K8=qjx71`i
zpps{aFQuB(q^0V6f`zE^=1o<aWhy5es98#4|EgKa&2pQiFt=F>bDL$n`jA7>jJUBA
z-E0fDo2`6fe{GSiJ?3^Ug_e`_taE%%59CknknbvgIpvZILo2S6W1b1hoVRF@`284~
z=npXfH>Y3q{<&>qd+Xa46jXm0IfZ|%LMvvQd;Df3eZd>jwbWz(zre&i)=?<<Txiyu
zh01SB!>&WCu1c1?#E}-p!vW0RoVWI0i2LH%+B5;j68Lu?TOuG+EGRA6ZRyh2X7Doc
ztH~xA)VcmdWT=;+rmkhU=QkcFUP#$;n5+`{)!ck*WiqrrNSU1H_MRp^wixFMgMQt^
zOx3=gH4;J&)@S4pV?5k7$K6Jsm#{hvIM$d(cw2pHveXquJN3HRQC+2V*7n>*pPCbm
z`-s_6Jye}|z-Q-Ij>|`yPy8dTApY#c8%O+jaxZ_EcT)VgJR6OB`CATfym2r8pFBIs
zZVV*PlE(-5&ebNX7h!2aOkv{$*BybBPt>*MKi(E?x*gOjJ9#szSJ&jtv0lx*CiTM7
zq>RzD&dATde67f0y;PJ8`le2IbD0=hN!xHAQeo~xDlDLe-=!4>b^0TWRXCm#X^*VJ
zc`Tr7wbJ5(>b6>#Yb8?JqiZEnSU@GPrQHURrKBb`Y!FOZaL^d)F}HJww-4KUXSumt
zuwx*FMZH0UIq#O*&v`5F<waFl{rJDpQN>x5g);fJVS1j$Ln}H&?fGW&P3Ieqj6wBb
z6!G)cENT@!QkF|eW)+D_BHG6+SSOcRi_7P#tWwyXb*Yg*iul0%^^B<hD8{hZ?O7A$
znjb`4JS!Jm<o>U%l#Yj0lKkON>H*p(XVnOF)g+6x4;3)uJ)0?hA5?fsI5?5-l+cP(
z^Y+SeNvKNX`RY@>dHiDL+4%0mlo(goQ>9l-jkMe2oP@g38p0~~qi&>58HiQ&80U%s
zvG3~SO~r7aTVZYAk1F?$<a*sMIkTzD1vE&c09>Ixh6koV&o_q3GD~<!Y@^m%EF{`T
zFNLZHFf*saJxy}>;wZT+iw{=LhuEWX^H;SiRq}#~twN^q^XG|)tzIy0S(xZXab0Kr
z#WrJ;>6i3qR|%H8B*X5|ig_k=Ig{%bSBoVD>fmddj4aj2>Qmi5RzM)>XH@R}UT*mn
zFL}CRjJs7EP*qDyv!(<$=MAJfVe>>MZX&A{Vx}OYrr4}pZRKB1SbB7E?HDVzR*T1w
z`bw|ltRH21MR$+IcB;J+srsQjXcQA&(P&40GtvKxbgA6CKhmCm>6NQ|+`x3Mk$+mK
z`XriXaa{*cv;?=J)StOO`kurqsDBUpH0gCMr3DMQB!$*6#!TcTRCT`;)V&j|WM#^t
zRv5K?_f|CIXAL*m%?}04j55_QBZII65a}-~OM|fl#Lv96*hXwiN!H}*Id5?r?^;t^
z+S;<$NFcX}?Ec80rMT`}P_ny9(i4*cuellCB0q$6t}RWqrRM8O$RQ=o*<YMLM($M9
zS1dm@e$kzuO@S5@J&bLJa6V1pFWh0bDM;Vl&=jubU;e0Q8PB3NK+zOm?lwSE7xBVF
z<7T`Ls&pIR%hDiJ84+_{YT8I{Y`i@M;_a!vTlK2BCy6YtQQsl|yl56x*hlVbX2LKS
zI<dMk7fCI4<C%RaQE}BOx8*%SUASckRp)Z2^06S)o?j{8O;S($&1gVczg<_z8X!^S
z)>p1R)@@#)>Mn#fZepRTBPHIyzpeH1fVj=9JHOh@a;2H&$ZcrU%sPdtuazVTEv{VU
zm%CZ_)NgK!d&g~Y-VJ<B?$w9+r%^rHk%p?Dq4S})uxk5lt=xy@g~#cjnra)@s4eiS
zRgqSzpPb(za;jTD(cRoH=_Tk_r}49qN=9OJIp!`9eOlC2C$b0VbLXFGMAp|GDjD2h
z)r}?t#gNLqLnE!x?ZWSiS#zbNRJ_cI?wWrpnyVtGFAuy_>>4}2lQg|ZdVWW2@|}iq
z{N<tQO}~;F<@P_%vtZQ8)(&ZkeFo_YYZhvHdsaKqotoev64V~6?ix;XOPHS@?XUgj
z9;bbJ?Da^ixXU>jg9Jr?!h8!opX6m4OV=AZt>$JI6y=HShuqMgm$+SfL0t?ISK1#&
zY|N#bHBN`(W$Dq~a`me7i9pp!HPPiZs=-b>%QkY1SH!=pyk{vHGPg(DKk6lpr7>~|
zlXZ(ad1q6U{Grjq=g)IGL=V<xvcbVXkv54R>0m=ER_&QDS8yU1NK+LH9~-1^L^<`K
zJqz3;@aA<^B^znnP0g;GdH22Q-F@=@uX9bdiZP~iq-2kg_EeI}KQ>e~PJZ)4Rp&_3
z2dWV6;eSvkIp1;z^7&@)bZ2l5FVEV+TPpVr4*jWsN^aVoD^tbPQGRj#`<1DpoDX}W
zGF1$)!PZx%rn>Ce%2YAZM%dpLq{?gC{d2GUa2djHp?>LJqV1>w@4cB3T>bOAZP$|_
zw<pVai6^a_bnv=YkP%xST)iwMa*V7qRjzfGnY@P6pOsr42`+F`fu~mP?-1>W!fmK}
zCo5%K290nu-uK#}>a7IOaywgf@5&+fGJDpgM`Z!NeL?RVIiI`TeqO3P<MdC)f?qa)
zp~`8roErLWX%!2v&REP}T0qvKK1*hvVT*>fsHSIYOSw#vc3TG~IUpAw8SArTni%rQ
z4y{<?o?F*xJO4Y^TRGoKd#T)ed9=J~Kld@$jrViSUZ-1lp<3GUhN?|@rr3<Beu>Ow
zMhEE2o!1tR`Mimh>r?uL9@`#UW3QLY)eo!O+cDaj=@|u->68>Vv$+11%DtVULkSk~
z0fS7p(QtVK)(+VpdhA{M7oJr9&1>ChHED((TOWG^Yj?lMRd^}UiB`Hc)EYX`Sp-z>
zJuP~ejw+g5uWlqaRWF5hx_7bq>%9B1jIpGQ$f5&eG^USJF?X=HjKqGZ@4>Jrn(bB0
z`9=w4&OY!cOZJQzWgRQ8wzzKhQ8GNLaZZZApccjU?BDO{eVc={BY2h&a`Hd*FaPTk
z{y$&ue|m-dU*xh;cl)2duqfOAa@POYSH{amTW7r1TjuoA?&lrDqC|Wqa~_fU(X;7D
z(3{H8NDAcHuH0b9{t<c%BU-g{tTt!wKSZ99*mkj6@@+KBOFfa+0aFrF6>e`di4=1u
zEh;)<(OidD@1#Y;GjrbBSY#9pEi74dR*OZWQ+a$w)fUOaHj)9;*w9mRj|e>#%?v&E
zyS>+I6daSDxsMvE%q`)J+5GKSGIS`<<FpMa0|_bMO*o$t$rzWX0i}Oo17mNNutPj_
z2oX!Qu#%yX#JyQwo{_9R<Sl&?nO#C5CoMXwwe%_2?}&zElo5!%?ABO)idSyV&XV3`
zgJBeO+L*Uyp5KiyDOS{aQeIK|#d*Ws0I%A-0qNB`8=(sS@GV!_%ZN-I{=b~5V^{Bq
zbq7;_c%hh^tz}pcT_iV`3C>U|x&8SDb=JA$Y^|wEu@ezVjTN=1+>~BFj*{my7S13J
z!|NgOII?WkA+~A3r~650&pHz)3T!5aR%EowdoyaqR#U$jBq1BI1z65uW?FK-(dgtz
z&^wyGsHg>psrxy(vEeQDtVxgf_N=oaof;?Jih`1Ox2}1+qQ2wzGkI9>GAW0-%At#f
zx8NqptiNnbZ2joCNd=vzGcNp(KH`H9ubZi<>W)ub^2I-d{mYNzYaYLGWPi$ke0@{S
zv%HfV><OSz#%rCA&pV_){?wFzvA}qs!lvO|kZ<B+C0H|Jr=>Z`fj$EK8ki!OdJxxm
zi&v%J7!I4q7{sp|>TeU4Vay}!at)KYnH#ngHe16UO@#3rvFan|&g8tP9u@uch_YK?
zw{kQ?&yz)w3`2&=G9bw?9Nunjn9N1oup_7^_Y9d)^w+$IF*rBguP`^>Rg4&980|*`
zi3KlZqQN^^*%p|aXFnq#l!k~mBEiJYL7B$OfVuG|z}$Fq6Rak|9)X>!XS@t^&p0HN
zRT~X!4|Bstz)CetbZ>_#TgxoY&Hd-FO<MB(RGC{!(E=^fcoCSJ$~CYvH0<F-*qgA^
zH0+B+*nXH>4$<ax&+QJAy-mL%ixh6yg)os7#LZD6>@Tn$8umgW?0r~{hV4m&9m9j4
ztzjp^-1LURL}0*gTmb8$M`tIF9!bO6s`qUOtfL;C1v^1mC2T%N{l+4gEU>b|4Rcdo
zn+W?R5q3EGjPB7QnCxq17*k=gTFA~OOg0rV4AFRW<7L7w(yO(BiOi$l2*dg*%Yw~R
z)*g1Dvd*vyW!W&1jr1GcVAGZ5!e%ME88%Vb?XW4zmcq_cb}wwavSqMQ${vP|Q}#G)
ztg_{>3CdQ&+A7-#8=!1AY@o8eurrnY20Kd`;_AjAWe#kpvQ*d*WukXkqAVRYSXl<_
zIAvi_N+#km#o%%3R4Pkt6daG%7g7+;bnpaS{qLr`Wj%~53F&E6>Cv0OJavlOTlaHM
z)t%)+=NUPw4xEbA#ci?i6(NI+I&cj7`aGBF2<rl)2mC@^8=j7CJ@smw4MtRqX0{>o
z!OM)x!7Aepuv(>uuTr_mg({)BNQGu{Y>_7IX0HPCZIQh_)s{9_U~dNt?Qg-w>L>6z
z<9GP=XtYaCqz&F|bOv$c3I0W&m3y^D?=wac@>jiY_v@WnX3Qt#LE~2NA>)4V5#xFA
zF+;4ZJg#;Ro-p3maFK9*RBf(2X6%5kRO<&F?VsSQjeX!6<9BeAkxpOtlF<=-8O>~Q
zU49n0-53hi856)AhFC?|X;gxHjfLPF#*N@+<2LXel|nVlN8qOUcd)g&9z4|C3?892
z6WTPfnXs4eEb}+8gLyPPXh*XXc%s=0?5_3`x|xHNmw>03L%~w>9PnII7GX!3bHLH&
z0&s#^2~IMrz^lw<;6n3p@H$hB&33e31ecg=!CTC)!P`uk+ud#+1m0<8flJMkz`M;;
z!1i`A*wL0Xl{?L|!Mn^+;8Jr8_=G7w8CIItg3p@|gR9IZz^(SH;5PdWu+aGoe8K!0
zTx;$CSDN30Z<xEmC(NI~Pt3g_?SrPj%?yE`nwj8NW*cyac?$TQc^de=*$3Qd_6Jv*
zCEzdSSnyYKDri{KLDQ-LQ>?jQ(7Fw5VciS1vX+6Zt<~Vc)&}rUOYA~qTAzT2TVI1)
z?KIvW+w2x#p>qt_!O8+VTHV1eRxj{G>r^n;8UW^5=YYMf^T7g3mQzo+mVjqiVlSeP
zbuYNpei7VeuK^34cfo<yUJXBrchELF3>G>$;CWVWaFo>t9B1_f$6MpTa_a(csucw<
zw5|XzvKE0+>w54~YbjV}-3!jO9s>VtJpnGZ)`8brZ-CcXAA|Q<UxN2rJHQ7lhqv8x
zj8VjXLR)Z^)gD}JbphY7WGmoJwH@)6H3a^FT8-Fdje~z~O#{EMD#0(Uh2VGAHQ@Kw
zP2etTDfol+IJnzd4jT3wpk;pz+V);BWIMcJTiIz~YdZ`cX&(pr?4F?C9t<93p9dao
zi!F$-9R-iKuK?TIF|eb(7)-J62UG25!I1qt*x%j+4zOPb2ijs6qQw3b9AbYCj<mOf
z=h-%I=23P!INHtxFR~8@FR{CWm)oa;f42LATkWafHhUUa=v)DQZeFF~cWd~)8vc}q
zyssf2X~_5BLDn7(5Am+vX14|lo#Vl_R%dXl-B-iU)bP<@wk4Jvw%T(we7=TX4?b?)
zs^L#)_zDddiwz%Hn>D;%!@tvTlehfGRw{VC9RhE#j{<M9#pct^b~~`p=>^_t4+ihD
z&jata%fP?bGr>Zq5`4t|Gx(@|H~56T9DLG#5nN%v3cg@(0oSUnhIMup<A9g!G2rX=
zc<@d8VsMK+AN<&^1-IJwf!pk5V4?FY_@TWD{8;TUY_+%Q(a-egPa3`t+-e`h$YGn^
z3M_Q8z;EpwaHm}Y?y^UKKiDI|-S$}UCwnHi$Buw|?K$8t_VwVew%B3#r~NnZcl$Xo
z#d#A<bKVDo&i7yo=Qps>p*vKe%qo84pDDbZWrmXx58(GGz7qE%zMVO<@o`z$c8|*2
z0-fmt9_In%^E2O;2RzQr<g-iBz&ovs78*X1C&`24`U*xK-e=~7St9VKD#q;l%UC1v
z`G5Gg$*y^~?mc=UTb5Ax{MYKmy?S-U@opkwN#W3<vZA3w2M<L%v~>8;B-PNI?Cc~(
z(46e9*~msTBrteb(Xe6tM-(wgO$25QBwCV=YfkpbNs7&cbZ@MXJZSKsvSB4fh5bFn
z=mRJu=VbRtQWnk0?wO=eN=TBbDj`X#yoBT;$&|>jryx6I`00a6`xo~|hxUx2rxy+=
zDjk+wtlT8&gq-YN$;IkQ4K=NduF3KWIbCy-JYy1)oa?SR$+_;D>=~1@lJ8Gfd}StG
zy<2jfiOcXttwmIz2bYwh7@S<(u4rkCaGpG7;$||gRFV+bBRnp!7niJPBKs@iQu1hs
zIIpUTcq)M+cP!7c$k#^3jh}|ni^$D>!7fvT;0wpiE)$)MvWlsfmFto1965o=agpZn
zXdzxeLnIkC$ci|EkRW0w1j;pKFQJbch|sGWE}4GEyFgr6S7ehv^1}3juB5JHZ=DzH
zDZ5I{_u@h5-Fh;;l7m;hU=dSPL0{DyBrr^=RT4$?7grJx7blkVmwRV<Lb)OYyv+-0
z5CWF6NS;-!%qyVCBa4{yW-qoYyIfX2J2GpW3NAnA9iSEwT|$MiA)+|9F7vJ^nOYT(
zivDaolX3&%N|x~)xk{FD)p%l}dR!L2_i^FNFhlng6}u7^G(_x5SU@!kWXc~@?E+x|
z<8zM6<UeS9?XiHmIF|*BplTZk3#gelS-J=sJ|-!`0&4V4mQjMLC@BmTIF3d%tgXjf
z;TxG8y23ZYT;Us;sJg;8!UCAzaHqCGooLA<H(-<#mZkAzBTiVrxDqCl=AfD;6c%70
z?@pD2#?2lJsCrqk#uIf;VF6X+lSy+>6$ym}R7p~%&p}n#6c*5B0hw?I8Rp1PQ^Iz^
zrfJwu9t$vtcBkz@hR`kxXf9>K9W>g5!UDR0A=B}oaSA9bpp$%=TnBX$Ei9l*H!?8~
z8e>3V2$h3<HB1%*gasJJx|8*waihlq#=Wqye1pa^j|GesFqz&5jb}U-&?%uT0|eD5
zp0EIeT6c;bG(PcIKqrSXSr6(2Q5Zs4piJ8l!s7KVjCKH%2|Vq<V*%qhm`whI82NHp
zfJv~sG=T87#{xz%Y@o(F(_;aKrtSg*P82;BFwTed*Lc%C7BCjT`e|6T#{$ii;^ff}
z&p-oU5`y+dbozzkP`yUrekKZL)6u{~_uH5>4of5xMN4jSc_e&cIU0eY*f%*kZQQId
zI(4%|KO8y!$c!0bf+m;K2Pe)BqlYglcXDuIdHGCq0;AJW9-J|GI{hYEdkNjTxN6_O
zJD&gVB9vglV1}#M7@jo4)fSAa{u%908yeQIiBl&}McwW~d|igemlM%bH5h+sxI;oS
z5)DGs_FWCV(VAF8eqCL_1~rEGCBpH7wC5c$jSPrl<Mil-<565}IOO`2b#)UH!6k_c
zckse^mxx**MRxTF-QFxberlwBMF%twBL+%;6=6}~kXtZgQdovdag_@1O*Bz;1NBJR
z@Y3SkxaOd~?o|Js`;9urL^LbHgN6?rNLR;$$*AyP9%P?!6mKcFlT0yi+#EYSHRdd~
zPtT1F$roAl7M-@_{V>m0ma}TiTC8TLo5Lbqs`ub9rhi6ke`o~~Y?(C~fkAx>ax;R_
zmeqT%s6VevcVWk@Jx@;}a;WC8npC2k@^ZAE7`qZNYG}Z5MKT%dwpQh_V^o6tP?a6e
zRK178jng@rsj}lo8)w0fF-pM0b!F@r)q!YZOeN%Kl_oz%$K^lqe<I)bXQoHoQMda?
z#sD(7pel^%ZjdMS?fyAfkGd<M=N#a;<Hg?P9XlyW8$qrq*O<X~f!4G})F%-ytdkHL
zjeA`6MkbA=NY(5|JVtB7dvA&h)_$aQuyNr;eQ8R8j^iuZQ}H*URITeBTA1q{S{U<Q
zKJlusya|mPd%+Hw%7}dAPJUx{E%r2nd4<lbmMal7*ni%Fb#i<y(u}|HD>l4$^E*8D
zaMpHy*&J*WIf5-OImq5sK093^>`{O}PYDu1N=f(ZnuGAe65ESt_<q?@OrLjh?b*v0
z{Gt*Oq%p6BIAU^YM))Mf+Wgjem#2rW79(%6A^4)S-+F)OPxl?kTz`eg8Y64|y!^1C
zTK|_=MQQb(P}Ouqt7FBENC8d|>R(h?8XJ@m8<8F>OkMq{HN<nH5gR0Kt+N*mD2QF0
ziuasFOR}UbsMLT+OCTR2|B+RxE20Vz2H4A$JQ+{6!Q|liVhVoP*|j6=p~IyjP#|q1
zqK1db)orqgPQ@g%rr5F(YU&+%NyL+?WHFeEOyzt8LO+ty?T`B`s&NjocOf?PeQa1i
z3PqmeqIK(BDMQV`ZE_vzI)42Uu0O~g()jwJDp}~3JX~>v2<O&ZY}SmhYMevuA4ps7
zqIdB!F3x4@CX#+UtDUyzU632Pay%)>q5g7dru(G#Qe?V_eo>9wo|4!wxy_}q!rV@q
z`9CT)tU$?FLPy5l?IdncB*Pq=cuS`>v0)?M+{>XUvBH7;Ok*2#U<vXXC6Y98BKzNz
z{qI$wYqm3~4PCt+(`HilFS(L<4z<PRwHW<Zmnd%i(+=el=UceY9$H&$mo%=0$l+20
zb4e$;c30Q<^NS-v@zZlT7h~%%xsJY%750l=(1$i4>2up6fjq8^n?|q3P9|H)$$nqg
zMl!o3OET--AsULC!=WX^h7^xT<WI8pS!SX=HM_o4{p(CGieno@M2<_TuM>N<s73FJ
zUnAZM#dU_X2WkOPvW8latIXjlb(JKgH#qh?t+A7A`)elqIkEJbl>F1#yw6k_88`Ex
zs^2JQ{u!aF-SS%)s@fsHeQ*gPzr~>{X}0-&Lsbt@J$Peks$n<7sTu6Um#vc)`tw2}
z<Q1kb8ZdB9+QvdLk8ITE#4c|U8<yH>Uo8KbMfq38F3+XCY>8b?yZV#U%dK->K$%wr
z#KD>Ozpzx~b9(i2qPekDi94V)R?=e8u!2~>jM&U{o@{kp*5J5oruZGm@*d;51xz=%
zk19{)R$Kg*F64QX>MkQjtS~HcT=E1|jiuG|s7Sq9kwXZI1m@4(9|%?V<v?*=Hqj+s
zb*}zBR?Z$)Vh_vB`zBPKrC}`zOQg^y?}GdaKYl&}xO^$hl3VjTZ@%KXuYZy2YQVPy
z#0n85iyj>-%<q@CJ#^&<1Vy>9!G&Mf_)ig^v_e;k1=r%bW%@Taf>3r5ImpCYb$TS_
zMXhKnM`BjUAtP}}-_gi~tty_s&xr<eUc%GplGU-*^=XLlZw%eACbovmRh5t~GAL*|
zHgx_{7fv)JX}Vde%99)q$d9c@$TC#fMRRnh7AQaVT2bDnQ03toW_g*e4Di>>PECvS
zA_P7|)v`=lT(=cRpHi+$v6QP(1~9-#E!wlj301wVQJ#xOSr?BoEYnSep7e2za!Wjl
ztj{({#SB%|YLtuPQRc;?#8W|9L(Kga*A0tDIWHb1o)_HW$ht81pD5nbtxpzBsHS-T
zo7)g!L+WjA1`Ryc;!1f6uAGw+o9%SkSMQHqp5N)8ef2F^x$4czy(ytTEv8CCD;D!u
z#1*Gvn_PFV>7f_o;W0ul%$Fa;(|AI~b9qLzHyx)~J-DJiC+DsC`+A^erFozqMFLm6
zfZ$WJW)c~qN7XY#)=<x=+~C7ca@8zXelSxTL!Nk73(q;VkqU#?zw#O$GCcN*r(594
z0#@~9B*CK<=2^<Lzc0`Nhv&UYP$oecG=!>yC3!MajdQ-&S<Ll1ER+>uo9KJw^&>VN
zI#Yqt4-FgAv}fGJi@QGPy=$faBdrWvM217PFSB_N?_0@TNweHNAQ6yg_qs&lN(XFz
zfBN|%awyVOa`hoYhm|zGX5<dqdc383r;2x?aI^ILlfM0ZT~`DTYX%)#i&*7`W2wG2
z>Kjk)=_MEa*Y{K04Y~L8jGR?^KUe9?g>=*18#&10UdsJH!2PUm85gJ&Z=`4gm?Rgb
zkj9)+uMYLOx+Ybc+FaL7u-<swdm$KE#AO<L6Xv1gUbe4V6RH};De+q!ztK-LzR?{;
zkWp{6G@(${C3Jk=&5qwC?+u8aO7d;~l%CfW;g*`t;~s}<zhPrcbNeaezs&8UoWfQ0
z&DLaqz{@0z7$>jC5q*dAuFKypPZWbSI{T_dH(vEx3iCUyXXKH$H+0Qt67)K7Gt!ag
z=Fg}6B%L)KsyIVDw5EkQxTrX{g%zqknW)wKulTAilNb^+o!^=wqvlXzoU%Do-O7!y
zqweS3-q1mMj6wTj`^Zp6{h2xh$l1?8ji)$69_u4{tcfEJb$zGM3oFH9K;^0(vCUqO
zQ2CiDodSoc`;2Jf5$Dy>X}x4${GTB-UgN&Rijifed4#Ior0iOT7UB&oQyWj-zB!qp
z6~l?1VHNSDWrnI{TlMt3H|A~UerJ$e)v08h_9EIvRU*amAK&MF46^blWT>_UY3kjz
zHEYAYe28HbeAulHRoAl*{D<lGZFK7%YIN&R@<_D$BNt1@FK?gf+ax_&W<lOYX`u7I
z(tK1^{K!qBZxYk&e|Wiut8t5EtaxvhG#$4zr;@mqraMGx&n?Cp-v4sh1GPl26%KD)
zjK4Q3h9>tF^HOR0@f%mP%#4KfjvZ8!kz1Ub!Q1X{KP0`L@e)<c>%02q<OAB19H_0W
z%Gp1EUlxv+<=}|@)Q_m<WoTRbT-(~`u}$%|_Nlft?tW5R8<5}WHM}=pbF${SSzCKM
z-qtcwy>`YWGLzd{)oxa@nzXgI@E{s*YY)i#=76K>1N14i(gE#v@6Vm2sug+zMDLG0
zxh)c{tx9Z({b9<DZ&Tye=Ds%f&N<v`50ZFM-piq?PNYa%oA;gD&Vo`5>Qx3*rT<Ma
z#4f*E2$5dVLTrXKZe&$267WAYG94@Mw4}>BLT-NX{@C8ey^ywyE(dNIA85<?;NP|k
z+9LzQPOlZ`?W4)G30;#;cBNw!Wz))4zv}4c4EX-6YI&r*e%6V0^eQ)Wbrwh6_k-(;
zG!Uv1D}!3Ubty33!!jgIobaQxwgH*4JT=^4accf&PEplcq3RpFv$oes-<OEK&W+Ce
zuW9@$S$>zRY_Ge!ar`CC<C~g(_jvsJNW5iSKt2+wYOJbIBG#aItRiB`_$CoEUDNxL
z3+eUiv*Iz2Y@D9Ps*)8DjYSL74*HJo8XlT&<jwt`J~Sg~n$p_l&Y-1LoG*g{=|L-3
z|B9v}D=rgBY=2fQ*As0K8Bf)>jE~OZ>k*CKy60QGYMZW#$aLoiMo!xF5(^@m==mBZ
z7&U|J`TP1YjgLkpnp0Ekdvjaw-}jqF^pMzq(wtSicy3t5EBo-3ygiKiqw?Ib-Q2X;
zfYi$T1;*U3<H<7%ju-v_b7Xr%!xXtu-^<WYT9a48^KD(*X^1K6mhI&&EeljNeGWxW
zsy1?{9c?G;2Tj&_cGb6*@>){fmujZtYt*t6b9VP-d_LY>hn>x{*DwfeoRdQ44l8*%
z<MMi?4*OyQTHq`@V_~hcFg8Hf&N$jWHb7?1Z>oxPqxz@la*y;jG+h>vY>6llcbK9u
zDQ~(ow34+Q4rMKBu~Mclyp$L9dB)+|&^CmWb=m}Lf%P({rs2ND3bWlwa{>LIEEl;W
zzD2B`4CqIxv<WB1)`i^?b+Re6!mQjr(A9{d&CyR}>l)xiPR$Tm1I&&Umew*&kh%VV
z7SvYdzN3kx&dVu(!4-j8jK~p!v(?%RZJ$G3;eK69k^|9n$pN#^#3CjIEQnR4#`dyQ
zP*^~m+(j3NGKE&4yN*Jy>Q<mwtIJ}lfD&Gl6}HG|smWtyyeX;SCzcfnsia!*A3Ch`
z$NMN`!-@?TX%o4f<M|A9J5!<vlcr&%kw8fzx8$->jsBaMO=?shn-GtUTqSxqH(y#Y
zOPEgOXM2Nd7P$=${R)@NKed46SSen#7(D^eZEBCrq9!X-{dm5p5q%nXUF-VVh=wIj
z?sor1t(C))N>*|zR+CiPl(0zGB#}_{Hik(}3SQ&)+OE`leu4LPi}rGdO-&vbxdBTX
z4YN3*NxMJ0ZXh?^eFn~MQo8fytcK{~QB^0TvU<h?S$7WSc`cx9jI`pyeofmjH*cB_
zgu-)+z4=R`vYO48BckLP=6V^4x$>ONEGDLht~9xjcm99cQ$NZui}cbveV@0z;-w~a
z=jLkeFnOOyH(qd{*%NK#fK$DQI9AnM7J2i$InTP89M!P)+-QBE$=Fu!&e;t;*;#UL
zM3_oasCc_+F84~^&21MOkRh35Jf@S5fXq3f{-VBld*^)ZUifo&<yTtjVy_{1ZSsKE
zTOxzK=GUWGyc_kJN67`*ff#P&z3g4;TlZ448!qMDkAGi2(TF&}^}K5xuzZmw<+B?u
z`fti7)%m0h_PFt9ao^u;QltN(gx<xx65hxHaC{4c_VLH{Dc2K~hXY?PF;E+VvSfX+
zyROJ8UN&n!^}QLU>~T_^`V-x7W-6Hye!LrQ;{V!Rq6}3V65i4cXH{*NsCNF*W6)?U
z9;zBdY-%C#R^jczXr*#rirneYpH8I*^ad=6?6zkPTYJ2`;0NUA)rBf$^sDQtReqSZ
zyzO<r(%NL$x{+DU>Un5a+1u;BCQQz)<2OG4lXc2B_%E$Vix8j&ULZiz*;e<2cg~Y?
zPJed*e^*lcsy{cxuk_+qC*oIBG^A}tC%O5nACtFt?nLG{wB%upjz@~U<Cr9w+s8eg
z({MaJ+Ri(EG{>{t<GB5e=RMtPEZg13VX7?PHr?-Pa%05i$grl*do)v@g)L25rpO&N
zxl5wK_W!Ss=&Ct*noUg$1Y5K`D3so+^}+hd$T;Ls{Ty~!=HdD|;)o+Vd7n0IIvsWN
zG2vs6J@&Y^$F<EmzTFA!JDkvwcF^==((W36lK(e8_J7ZplSDmFwO^H;zESo)VK0!2
z44f$<CQMj{nnHJ3nEy<tIpbxR8zvGdE)!)2mn~o%^qQu(5caCFn_<Oz?p?4VWydk{
zl>O!mqYCDpyDAa3HxU+Q;Oxc|!ShX;-bmO+Wm8~o$}?bY$`>$!answCVE4%~y<S%w
z^SSYcF|BsvJ)B@iP((MZBEed*X6>GP6wE#MMVK4!2o{1|c2$DCmtdXPId#wN33JaC
zAzhJ4@*BHZ^K{Q`#}?Wn8g?$s4f`>{j$#Si4V#-_pC;IANEQ&4^x7Q~k9RqY%Mf;7
zf;ni+xv89xU}q-Sv;=!N!9Gi{p@+rq!ksWTmA;vA_EdtMzz(Z>^ri$$Vc*#e6Bkl0
z+XA~s%iFU}JWO1?Zr3nz@%oW6aq;@0GI8;`MVYvGeMgzNczs*heArvcs$g#_TL_bN
z62EaZ><wj$VgFFJ1op17n_;rB;x}%Gy{Bv`>}zHB!ai2E3??#Se&b=-I%SW;Wa-6k
zEQhUDwi32R*>kY9%2vUiQ??E!YDs=$6YK?LV#9l-vdyrkmAwNKc{RWB9_%G$AHiN%
zwhi{6vM*qtE87nHRM`%g$gug1ov^Qz?S_fk6Apf1Unu(x_L(w~Ab&`i1FKV(3frcv
z1#GLbblAhnGGMnTn*w`9*)*8+4t`@cY=g2nu=UCo!k$oeHSF)o7Q_CgYzgdfWjDhf
zQ+7M-QDsYEGV1Xg_rjJdTLu#;Kkf(Yer1ot{;F&_>^@~HVImjkH=cw2McFFY1IpIH
z?ozf1cBiseVRtCo47**~JFwf7y$8Eh*+;Oum2HD9RVM9QWNuKuF~VSJ+6mxQMjvpY
zF#xPl8`#&XpwV?IgL4lqgT>_P9Pj~Ri5i=%FFj<43f~jPQgDkQOFS9o8t@QPR;!LQ
zKLC$0w}Qu-KZ3`Zd%(8lKfx?BKrep0DGN<GrdY`CW*!ChFtfoza{$=KECGwmkzlbo
z9_(jM2K$>c!L!Wy;862gu++R09Bw`ijxlB7t;~D}9BY0Ajx)aiCzzthS8o0aPBul6
zZ;EMC8w<>q;Fac~;GfLH!G-40;5BA@@OrZ|xWvo>Z!`<Ro6HjMW>chdZ!yP%x0$oR
z+s(z`9p;VTU8c0XrKa33pC#=kV98S-wB+e-VM*(6X-UfuS>J;P<J(@8yTnn&5mp9x
zq;)jd*6IQtZ)Jn+EOAfK-x7JuGpzyOaO)y)gf$;L+qxDUY01>$T<aEajI|Ujv&5yu
zIBN?y-r5S5TVH@Pt)1XS)-Pbx5_P^yt?o>Ns;u7NRaPMwv&0ed&DI$3HfsiWr!^P6
z%Mu3;ORamrzgjZQd(aZKy+^FK!AGrsfR9<9f{$CWKS00Zlb*%~*IB9HRx1<SW*rB9
zW_1O>uucZQw0eR&tOD>`>vZrts~G&zDg}32!@-}dbHQJ&iQqr2so?L{h2VZ`258uq
zfu?;qXxZ~Yza0Zp?CZdQ{UF%Feh6%7KMo#ZKMfvgKLZ|SzX+aTe*pHee*(|6kMhei
zBBpPK+P#I_1Hg0af#A9J5OAzr29C4Gg5&LSu-q2azDf2haGHH3INh!UXV?qDS@yMH
zg?$5fseK=Kx&2pgj{OjLg}oe{Z_BdbRrV%uq5TrL$bKEX+TH@z+8=_~+x6fL_73ny
zdlz_%{R?=j{X4kSK8T0>9y<j7#TM1{zuHHE_uH}(^oZRRe9V@ez{l;L;0F6b@MZgI
z@NN4B@E!Yh@LgNf0{>yJ1h?4FfFG)I;79gb@Q>{ez)x)13EgUc3)b5|fxB#RDgC3}
z3*2q@0e`Ve!Qbt%pyk9s+gS=a&ZnT?Nnw0cnsyNQxqTA&h20hW((VCvbw+`wIOSlT
zBkFwlP6X`jh&tb?P7Qd5a~)Xd+y?e>9t4Y=XTV}doJ03@UIfo{UIiyP+rTMK9XQqb
z7ChhS!bt2Qr#E=9QwT10&H}G<W`Wl`^T8#~P2dgAZQzX#qKf1;1?=Sug8h9*f@k`U
z2M7AH!LxkD%FhH#e1pNEz6-$NzM0^;z9@K}Zvi;UR|$^uT?>x)-2zVVEd?j~?g6L!
z9tCIk#8vZ5-)rF0z7N1>d>?}^`F4S?_<jRl_4yblzUDg$eBIXpe8VSOpKtrl1>f<F
z2mj#{hsvdCYrr3T-+({*#EJ55-*4bv-?5A;_xZBHUwl`BrD@_C`B49LV5a{@@NoZM
zz+?Q+fu(6{!M6T)m5ZC?ll-58*?w`B+|~a**u%dY?CJj<%=NcmT-wWj5LoCx0_@{I
z9xU?r0tfnw!L$7R!E^ni!BPH+;0(XGPoC))75@tV4PexNH+Z#w16b?d4F1{QfiZ1q
zS~mEBzX1HuFHVj>@s9$x`KN$;{I%fE{u{u({;$E(wC}*~DL;ZeQho({rlc?|%}q%I
zd#8ww&Z#Mx;AtuCz=9M}@;@_0l=%mwoCXd|83qnZ83B$;nF5YZnF;<ar4n48QVXs~
zSqeUt@^|p*l&8UGQeFU8r)&n-q-+P*rhE%-ND+nnjVYPnrj(<=S5mUUS5x|duce#`
zZcZ5izL_!|d@E%p_-@L4@E<AS<oLamTfq-g{tAAS@&fop%FAF~%0Iy4Q-1~9rP>U~
zPe?ro?2y_K{34|Q{KOasZZ)QY+l&hEGvjjb3u7KwnpO?&FcyQ~8MlJF3~_$E+gPD|
zlk(re(lj4q|KE))aKF(3G|jG{Wex@%a~SA1&jC|Sk$Mf7;_A3G?Hce&;}&p*aX0vs
z@i4g3cnW;hSOu;!wu7q;ad^DO*bS~V_JivUaen-g(HeZ&I0}5l$N^t7dVr;Ay}?fA
zSzs4)G<c#pLBr1npE552SDJId=gq6Z7tEW%HRf&LTJs+8RdX5mn)x*Ny15#B!(0o#
zWxfNxZGH)srtMHJPL#Kp;zap9Q=BNjZ<@?-J~O+3pPMIx-<aY!`8%@+{N5Y|?lQ~4
zpUm0d9<v(!*<1)xC*W76I8OfBd<@)fisR(cwCBJRtyjQos~+rTeFyfig3O3|S_gx<
z)`?&*s|QF8fW56D;HlO*;AxgPQ7*9NfrZururzHU__9?4zG^)IzGgiOzHW&V<u|PN
z!MCkC@EvOx_^u_+l0UFofpe^5!MWB6U}>5-PEL0Uz}8MVc(5}QJj9s~9_HK!W;%ZZ
z4|kpiOVieYs~vHfyw-UaT<5$Gu6M*u@&@M+aFde_zU&MFUvUP5uR0UJ(zNrzPkiDO
zd7Ez`_^I#D;OD-j;FrD^z^{BSf?xaI220b#5whj~3Ut&Fvd_N{p5jkuHkjr=5e)cG
z0)zfSur%#V@Jau0@G1WkaHW4b_>6x(_?-Vv@Ol4(;0x;fnEL`hI%N|WPI(tRHswRG
zZOTsY_>_Z~Rklkx0z5&TAD5<ehIdZw1$Ifz19MXQf!$Ki1be0q0drHuWpG}qI6}@(
z9S@$CIu$HP6?eUbsk6a8sh5F$Q~v}WpZW;cF7;`!G;I}Fm-->NBlS!0yVRZF&QuF|
z?_H^>;E$;-!F{PmfWM@+0e?+B7W_Rm8#L0+1g*3Z&`BE(rlgGp)6y;jgK6`@mTA>s
zdfH;Jb=o~(M%ps)(6k4^!_yuIk4#$w9+kEUJSOdB@VK<iU{=~^V7s*KVEeRhz)op9
z!7gbQbH9_)Qo$Z+VK6uCRIpdtY2YbogTd0Y5#WHdGUW_2oB62uf?3Z;gcBk0VQ`|#
z67oBe1C5XWgHf=1l-h@#kaWC2E@CiT;Zw%<cXHbJeD^pnQa+RU{&c|Obo6|7DN^1f
zRSe0q<V{K??-1{!su=$t>Pi1sD%VXEXS-)7d#~*-YQsr!nkgISoSdw-o0IIzHz%i=
zl5S47WcA-1RJxm7D<`K%va)YZ^Q$*gNAA{4`M6ux<dnN5dnC^3)~poWx+Rr8r(5@A
zRpV~mla-;-OiwCBw;s*nG%HuPp2^zd-ICp6=X7hP)ZH!FEp|?~+-B+ICM#ZdYo^lO
z4ITNWHQ%jyttNXv&gq`)wV06Pl6Ft_1)bBqnId@iW@_Kvo7HM}%HGI_wd=pSxij&c
z?#*hXdv5YQ>(Mp2RrMfGhczh2yQvQvTzY^D^k|mZ9?f*rdmJdUrRS6+n+)iY+bko!
znq@ZG#Wc@E@>xBT-E`;l?3#Q-dv;B3mOY!@nw}>&i<9hv8)xmw4@J*p=jXU@Px4<t
zNOB|W***D@?3wH!ooBsSDS9-!db3BVXS2toXH(Dc7;EU+tmb?6O3q<!vYYOl-0YrB
zd@iWAoOtGy_lRh^qlh}u^}sA|jtE~@$F3|gV<tVmYZ*W^={!9;29?Hfd_|8=(qRB&
zlt?;gypPuqULBgwq-o<OyI#Jt+1!$AO~9KK)(KP}Pt1<X)kObYRMvC(FX_&hg<2|3
zE6d~pqJl3cOGH<J6bBr^R-L_|3A|f_t@6Ep75L1=6ZXtV6x$x+x=RZlzxKp&k#X2l
zaMP2_Nc4$iS|4I`U?iywC3t%IC0dfkm-e&{)$Lj1i@D)BJms#V>fw^Cm^YBL)gnRx
z(M#P_(PW$uMM;$-Qmx|aL9#J(re;%$q<`^7ru7pqqd3i$3&;O!DcuX7td-Ht%h6Od
zv>?f9wc>yDLb1yr_b6V46VyL)ytXA;qtv=;w#IV)NU}9yyb;%ulr>w|;f65R;fAn)
z@hvIHK1EQ+6T$+<Z-mKS4NC&7aS96<LD&inll4|%0rg5K`&IZtBurR9y%TQKur7oN
z3mCbu*EB5OW4H*0$=+Gekab#N0b>MA_UwWf`f{0T8{iua6Waj70*0*J${Kyph<MDk
z7a*(uuDt+ZuDt+RA$9Eq2y^WP$UZ<&O}PmRsEDNO2w+En^n?Y}3G#Lgdz~<00Yg@T
zzt*sA9t)@!LD_2vswqHWEboA_V}au(kGVDkWIw~TAt21PAt1XGt_=ZUt_=a%<8W;V
z2y<-+Y}2rTpfJ~lfb3YfHUxyZHUwl{IH(2%g$2}*rtIznjVnQ60Ze5v>eR3$9t&t2
zkbS72?k)%m=q`lp2L*NSMp!`iJY)wcsQVzo0=lF0zJ^Jv!UB4ywrJRQpfK7MD67}B
zE5^yf0>(iw*`*3%7|Ue=%wM_tUqM5}PGlzx_uDYp3B&!i#{#Udx_e?lqo2oULoi(@
zXKmGG0b>emvz{w9$Atxq%V4r&7BuF0EWp~R%vL3AvBv_Kj$+2BVfT0}z<Q_5b0yw#
zj|Gf1u$MG!gU7JN0o$Nq?|Cd>d<B!;qM-4O#{w8|a(CN;hODBm<7mJLFjH8o@ecA>
zz-R+orD0)@Q7^DH8rH*O)C-IibFLvanT1g=uopG#T#r#NuopB;jGGFhUSQ8^*gTH~
zSif|4^n%7s9t#-v!JgB24|ptKJOz73!=CjRuBTy7Y1nHX!|n#`X$||_W7yq*$qr%A
z_{n1dLst7`Pb_GpcnsgGFxedo8i#uf=W8(8cMBSwJQiS8)!l&$8ofOhFb2S6FD_^d
z_E^9e4U^rKAnT_t3$Rw|?#~4cG59Atb=aYR$xdC+sP-830+T&9>cwN!3v8K&J>W6w
z1$MuNJ?k;*1@>1Bd(C43<3pJ2=mm|f9;1JT-K$}{Jche=*k3eE6ibBRt{rx_h8^ND
z+_l4&YS;-L!(BT}b^~$O?lJme*qs_CI}^fi*A9~%!k{tQW4LRF-L7FXJche=nCuz`
zjRhXVT|4Yn4ZGfB^oe|AW-7Dd6hqcX-Cgk%W5JG_;Rw4uEI&)K?&W6~cJpi71ZoF}
z6KBz4TTUR-e2z%;@okf{>gUxn5YC5-jz*ZTxC+RKv|NdxnMl7%qH9GLU((Cl8LDbc
zt>tYFRR#D(?e;l>qb(t;Afan^)9TJf3`jD8R2#{nGSF}SjW-*Ms<Lh;Fw!oTf@Vre
z>}*Grkd|3OMK`?PG6%!neOq|(7Mv=!$RnY$F)NWmOXMV0+yW=d-?TxEiF3lCr$!tx
zJoMCb?2^BWT>;5VZRyEvI5dYU(9$l+nosDWhqJVL9?n|HKl@#j<f|kY0YXX7M|zyU
z$qkA~P|&@^OcaE_Ns+^QgZqd+MHGeuC|lw@dG$A<3pG17C{^P2$tvLAs0FJF=zU`A
zi978U0>(bgU*qR}lVZiKSAXwRer=*O(PyJu8yqn@eKV<g)x`rtPi<N`V)*dkKYtrr
zvwHh6_L{s+b9&ZJ>u=Y#ctoNNNl5*wHeX3JT?Ld!myL<vC2G12FI1EuDf>DIS-=57
z7sE}rj{7eK^pYpPBSTLWr`Pr|ER_N+<@|{pH^|!(eyDY67rFEN6oy}<QE`$TX@5&?
z=Lb5id2_F-=HQ6BPpwh;t&_KX)<GMK^d$XP@k90gXvxpTGL$ZebmU4Iaf{)rx2INa
z6SXpFa-Fdxjv;{13Mat7^!lTaAIw6R`4Ev%L}s|<o&tyF;=08NyXl1^9Z2uc*of4m
zB$0p)t*F8R6J^IoHwm`KuZQ@C%0!#5gc9V|wzwv5UqyPSH~O!xvrgyv`0*h*RQ>H7
z5l2RgI&ys8C!xx}lWqQ!FC^YtSb497s_r7FFz=IDJL+zLNu*kS>r)ciJO}5!8>+h0
zi?y?UmRpj@@yJa|!=(D>^J8zyd;j7Qd7o4aoqzfMKxCjK`BQxnk;7cPHwSvDL!Quz
zoY?D?pQfnTHaeG^VjH9!w_rElUL&fHtM}S9PI}d*s85pEtOYH_bIDtC&WpX?>6Hch
zw$t$D4yMrAXhD1%x?`2SHgEOCqRpPqeay_;P%#^qj0JfwM~=mxR{O}2c^hVZS3i;P
zu}GbHhx`QYt{>cw&@-veY_42D3UkDYg_!a$EjiyBG7O(+_foca3)&8MH6^3s;;2s{
zH#C(RyXs<*3zj=UQ>C;4&y7LlI)`@5&4@Q;)FzOW7g<-0=slW|;>v$Igp|xVjxI)8
zIL`(Gq5D;dzj9-0?ab7KDu1tsvlbIW9i~i_$D%=Oo+Ku6bth+4eG6`mM8nv`n|mw&
zY0Yg(MpUL=J3jB8(fwUbB=526^#15hyUG^La>gt=BA($fD=Aqb`(g)+4HzUzYMr>$
z(n^?g*M39v{9N`ky}N{n#2ibMOn;684^h+YrRHe(VV+yl2jIsc=fN5_hKgCQWp9Qx
zX5$&K9Xl~%-g!OP9;3pn+Om7Zx~%yXc#;~F%+@v89Cm=jZ@LJy_E4|qJ&j)QUdHL*
zMC2scl~r%$Q`j$IX3HK4yRsO{mDDV9djawj%na2}`9*4g`Z6_yJzwpdRk8yiMxL()
zYmFPgYxF&Mt;!%>r=yzdbu4#-&U0>3>7$!f-snyw40z9C0+yMS(U!LRkeX9|3?tAY
z+j0i@Bys?<A5{*nR6AEsvzO0k3F|YmHzniERqVUVuGFL8I%6fc-gq8-#n=eGW^4xE
zU}v2XtS&LX#?CkM5%xl4Kdl3}lYMS>Wet(S*lmb8<)7HkmXN;SUZX$wi%|mpW{6*d
zUks7U_{}H-Epq~xYEA|ZGnasen>T~~%}2li=9Azca}7Am+yIuEGM;N|ZU)<#BCpZe
z{0KbJ{0{7DrqfosnKDM}ZXOHfnld)aGYi4qrue%mHHU+zse$DJ^AZiY0z6DdSfwV(
zG+U3qn&Z;G!+hf(wyg|_E59?7jz2F4^eFqPFp(B%e7<{J)=_v!_<l+J=Evn#AhpF@
zJL$NLJl$uaVLkq&B=e<`XUSVNzt!^ixF0oNT0Xmcg4$7(d<Hp)al!IgvUD=bUC@!N
z<+<Ur#+B&;h^%x-j#3G(h>kzMd_qJQStMy$5Aduf$r3?^7sP@F{@A@G5IH~7I}o=k
zC}C|RjC{D!Dl}W+csw<*<r-ZSON_VEXUMe@uBMM8FyaM9#cWxb*e#qfYuv0$z3W!!
z639a0$QlWDA<M>J8YwRmBa5=6GsQbuO)}~sT^L&81t;Q97*|n_70U`NU<F%MH9LvL
zBk#B@noQ$(Z>gq8bmFD|r?P8-lC-GKe{U}@0YPA4fw&CVu*mKXJw4sCJFw7yzuymL
zcM!7!O;1nHY_l`nL(j}U6y+r%M~nyokr;yr0+EOc9z2N(8UvVk2oj7C;}JtZ@N9A*
z;87xCzOSnOzp7@)tIp29-QR!jt-7~v-Kzglw?#EK`0|i;OzOkh_W~9-l;jWBBd40U
z6LY;!En6$@>f8$O6zI;ITTB~yJHA&@iOh8+^JNmBS2El9saCI_c$evlWkMt3-qU3Y
z6<sBM64|?V!&oct-SCsVcf(I|O-=7Q4XruYSwjbKBsJZs=&V`up=~$)!N4s?B_DeD
z#Ml0P)B1g2b6RIjwD!&H>2xP{_U76X&DPw&%o6h3P0%AZMF(ROeOMS~oY>vk93GsX
znsi<roJRIM@RsrS*6;cD+n^vHYynWkWumsh&eQ>iHL#lECB8e|ZY~an!wA9(8Jxl$
zw8h;N#kGzT3~b~_s|-%HCzobI+X%9~!N3F1jNYlspco1AI|3qT7}cnCpm63JnvMv~
zB50h!N%)N_JQEZ##zXY~c+@HiY1jhJQF!MIf0QGUE%?O2sgV-C38{jnG2L$qHSvw{
zN^+eqzIj~uJ$2;kYblI0gMF<SIu<SDohQ7W;=K08eTumulKwR(UxEPzjo_yg*Fu(n
z(Da(-Iv~HnpG3^MIFknhd}_$@lgw1#(-ZG1Nl?u8b_+=#3{V=&ao^vDUultga^91L
zG&Yy8T7WgOT=>EZcWJICBq%IvbKxZ`)a7yg&4vxnX|7)?F4EXs93z@5KC${S&Bc8%
zETplyaDU3+div)3_G_+F6c=f1F5w@33qSpn=W+GpS>s&AMH-vyaI3D5p1A5M&BeQ*
zETply=n-14b6yEuq`7u0F4EXscs<GBDxW)lx8}N0agoO66643$>#2SJ`Kadlvf?6*
z&4t&5jJiJe#BsN2uD?}Wq_MfU_SAZ<zw6%bXs#C(7inxRyuf2{op;(ExRGahuKid@
zv&w0-7w~kUy>KzU$x(obb{^w!?*+?{PPgtO_~5Kla@5#a#6(RPg_Epoa{$rcs8z4O
zE@PV+$2k871M@uMj|EQ^arELU5fN8||9f<1m^R}sd0Ea-Ej-2<z-n$B2uI7GoXK-6
z=6F9A--CRuNR$K4`fNd4Y>SdZ8rXSqT2V<&nJfV7bVVai4bDm$>PBm{ok3)LWMK;g
zBDl`9xn!Krk`Axypgr^=)ybZH3_Ekp5)8Z_M~;XshyGx6rJWhMgMs^bBpJ$DVP}5o
zsM^;G`%D6%tiKNP9E+(b>yn!Cj=L_NrW}!i#@CdxG}pMzWoU|*XO?LyTR3QF$}6g1
zfKN>hbIx%#d}b5A(=Mh*aXt(Nc#TbJ7G#^3A4G0uiO>^1h>w(Y&#*e}gvvvscn&I7
z*P<?o#BfspBnASGpWDa~uS!gsDCFE{BariP8-biFZ3J@mSO}hG!*5K<$kXmj*hm!D
zAO;c*k3?W2WrLvAgVaLy;H=#j%2&@(a<s3~Mw*LHy>wBQ7ru&{n9F)lTHfrzb%N$H
z91p@8@#WTIh)57`_25Z@hCgo4ILNZj@4>58?du%&;3sj8vc3Tu$-*Ao0vn!(uc9u|
zgLnzSN!ti|2meeO^v)SJg5IG{h8#%dSo9Fs8GSM3Bj!jUjkGhLGw9-t6h;w2<Bt?-
zqPe)f(Z#g$0AM>NNc)&}K3UK(XZMk~U$8a)*10R~e2Spqjt<YxC;N8hlQ5Q(Vdr4r
zEBHiNpQCe#5-LZ+^h5px)X6~LW5x>YJwyV;S^n(X6EixB@-8|HY3$i51VqQ)$F5uV
zqUQRs;v&r|^eJkGhu8etiQsJs=MWn~fBhI7vW29<t4Pj*kC<&fRn+b|(i!Pz#&zw7
zsGvz2Sv!7QLX1jJax_dIyTPa(2!!3^BW7KviMkm7S=QFS{*tb%pz0!xJ<G5z=~29w
zqKoHIoX`Y~?@{bC&GpYVml1o{gVXjX=?SJsoi1oTf#ZRgWoqNuTUL71dj-vvJmQb#
zbl;=+Tu~wesOww!NLe=~1&D(=c379x^i@xgAoDckEF)-qO({!r{m$kxH021lHI*$i
zHQgX+uE+5}Twzr1-|<%~HQgv^e$6BPST^{YenLST9BTR`&QVsA0Z0_n6E*<}1_lHU
zf4=Nh__=a*{2-5nNn?+cK_I~ZJ%r`sPab}l=Hd<{7Sh=ML%pO`k6ld)uXt8{Cjdd?
zTb1qBT)caxiy4vVdA3!hHB75=IS~wSjy%XY#JTnOd)KbCDuyeq0k35bvxI%Co~mjO
z3#&elbCea!k%}c$jt+$p!>93C)Ws+<gkO(wYBqwf@7f5)GUKkt1v#LZwGq%TK1&+Y
zSBXfg^5=ha@vO>gFG1s5mF?DCm)Kl}ucFFjR+ZK;t%@lMG*7}}$2c3E9ls4>TEQ1<
zK1Ij_4Ogb`!6%ks->Te^CXoTq1i(sJ50@lLt48<}EaE*DQI|kQ(0nGl(g<F}#6AEE
zfen8LF&<5HD1vy%_ecx`9san1pe`WK8C;Q}C~AM!Mj+=g8$n%Pw-L+*ci9Nc@W(a+
z17B?+oY7h~g7%;RW}E3hMw_7*bf5JR(>JK8^o=X+URG<ZjY_g!Ytj0ei+5#pF-II6
zeVK2_J~e#<%7CVbV*umnXOV9tSNaB&0nO)m#2?Fu?;ADM<`HKAH19;qDC?2BAj84b
zlyyl>x7ck~nsPh~8h;c}mgeFvLtRWw(b>y1l`S+iWe?%H0LK9C18#_(jDUpZTBG1B
zL30C-_+uIMHN8-2Iw~|h5v-K;-Z4RjgQ+R&QhjQ-S!sGG&I=k}Q_9j@587PDct0C-
zb`+H@G&S8SXy|`OV8p+4%<50B)Rc=fL|V|S!6%ljzNWjBrdx%kL!hCoL&hbY81E6h
z8ZLe#N7Tjf9>Ke+4i@T=L+c3y4)`?-;dROv4J10mE2)i;?r{NuYx8QtLn0Bp&njj|
z4*?D8dd`-Ear%mnn0-Mm*%v>st*ZKhD=b0d_XV}pT<(D&@QdknSS~N?3u!~MFXDoR
zJsZG%xi6hP`ID7>;R>49dBh(}-0zF4RA0oM0o27iVU)FWfgr=d)Rc8eP5J(bF5WD2
zFd#wWYf4#~>tdVB@VW%(Y_F3oG&M!w08JT3-W5E&^LK9(Nm7F5Q65Q#lJqsbQE8eK
zn)1Cy%6j)73Njo_O<9-JbdTL;)u->kc|qfAN?DqVdxCW_`!o&M)>O98)HEY#IAT|0
zmGb4%@cxy3niVu(;Sql<8DG;cDory&)AvJD%6e#rAj6@tu-Nam=H})1fn_T+)-HAb
zw5^5Goofj}<Lgf8n(KC(%jjh;lWg5(n@!#Gg60w&16ZTID_@*isXK0mLC#ls#2-uE
z*PYM9B{Be-Y3NQ_g$pHW_cH5}nts!6v(oe+oEJ2{rj(_*zH4(CnifH4Ybsl4YRctJ
zFu>d!6VB^_C+=<kVx^|^DvU~)d<LIbO1`F#D@{wHmzfQLvL5-cq!UqeWE8RPSOj2E
z7h~oKws|;rA|y$~yb7p*F&KD<V*ge9n&0U4{4=U9(%4r4Rl$YeC`$hyZuyAjdQ)+c
z#^&N`I2c$jnVj2Z9=}m@#SV}#X>6{#;5t=tZ9U+mi#1nQagoO6I!|zg6c>KSwXeDE
zR$Qd9xyA$+?+3En_RDV%YOa4#T%@tNwgCwS){+I~=I>u)=yi(n7Sh;U+kpfFr;r6@
z%UN@)bX{J|B#q6*=`t8NiYzGW9zWm)&Gi{o7iny+^MUBAwwdG3LHt8?qI^$rk;dkF
zACO>RgCuj-Ebcf$bNya%kw!{lz5(uMT<K#M2sy_qIp3KWywu~ty)kgHkjAe4{Xlf>
zH{Egb)0&GvbId{-n~Q-x7{Ej>%BSvKbDHM*s^TJzxR-)0EO`GK4U=sq3v(W9L{~}#
zV`uX)Xt?`TBiQWZ9AS>H&DbB}9AG11JUuwZ;No5#hdYRUIV0H5<8WuOfneS8vW-BM
z=M5wp4TI}qjCqeMIy{W=eua-vi#MSKcTamXkrCb_`svXY0y)q42)T|v7(dnw*V0`0
zg-z$f@3IhRy3R(RDSzlyb4Ader;oG{SnRtt0y$r?5bRTOj<At1uH)cyS~7MwIX^ZK
zSOXS&^F&PpYe3FM-x}z_7`Cf9{0Uwuhnk)aP4`&{b6UKGFeqsn_%XUU{CXW}9Yk8`
z;mmdM0;00to>&+yeAYyw?B&O71a@Y&3ZE;=_<V(ru!bfi-;X}iG`#ZNh%sg$G2C}R
z3^EXC%C~DY!aM)(u@Thu_lU@vhJAXCfxw2a>c1K`j0|I!lye2<7N2XFcee8uLXYAa
zThnYt3*Uq`9s<cgqK0Jj4lFk1Bh>vv(A_K2&Nui7EpM*SC|S<k&#U+&IlZ;$>#9Ba
zs+O~(=6cz?xg*%j71|CU_S`M!TyyT85HwrS$kn)mf9gM-{lLn(n@bKn?E;OrN}2HI
zZvHSj%Y-uknqQ!;ly%%^C5k9x+{eBMU@-7rb?V{Prpt94`%5K<G<NiB2(I;t>&$%z
zKB>80Q(UC6txCP5RgZY5Vio^+R)tfEr#{-MY`5lmz~(YmL>Gh8wyLy-Y1O8nc>>2(
zcp`jhA+~L$RVM{a8W!`c+VrhDh>^t76jr4NP}T=NFF+hj|7qg8)b!_eo7LLyXq*=`
z{@RbSG}obs8M>JM(*kU3DqCo3IwffC!I7FiG_wErm6|f-1OvP}_B5UHH9cEtI^_(2
zCV)Pmtk9h}h+=BWx}>J-?KT^l3L0Ni%F<jVo6G3aY0%l4$`+cM&Ip>{;&=$|1RQw6
zCmvj>=}tj&8#MK*n(;N|Pu#G~2u;^OQ_9+Yw*YZKR3ByJzeCW_Rz!vnZK#2$T_RC=
zSIs~W+2~Cg;e47hkZ5!SH22vEqTeGvV%nK<q@CNI8bIK6%Fb)>S<v`)rY4$;KM=2r
z=}{fPww<MYOgr<+BpBciYPNAVW#6-}UAofFy95pQyKo)Pa*1!}rn2)Tu=A?G<*+kl
z?S5F&(ays|*yZcobeO!NqMe6_ust3*Ej)y@%!By`MwDoe6~|_AHW*l^1peD$zdx7W
zFUz&6cGB2!Yz{~;aIB(RcjlvyXs+)lF4EXsT_E}?-dUeH<7=Ah6~#pwo2w_d-i;&6
z@w0yc!CnhbQWr*~vAO1fXuaN8{1zJPalKD*k;dji_ke2vN0xyj2R^2`ZctpLvAOy{
z^fS%%`_|+&*AEpJX>6_qi|hIeFT7H79d#&9qL9YsS_BddoXC?Xe{|)~(9fP;%y-2?
z8k=hgh`zqqc<2kC(p;ZZT%@tNb_=dEaAf(%ThIHE=K7K1B8{w{FWBybwwC~rvGHUe
z529ZsLeJ!?iP^(6O%gP#eFRTxVn{9FJnMU}@Nle7IX7!L_|<slb{oOE<t7W^I_f$b
z!AQB>Mo`z1jf~*EcN>X0V*TgU9*vEnJ+B<8+k?y!;9~wLNn@@P_Rtyu&wGbA-*}T}
zFT_je&O#d7@_T{kUf!SFfz_1P%Qq`7((o#2c!*D~&ppViT_CW=Nj_q>XP=OK9F8oh
zTdv0<#gqKBl1v&QIgHd2$o^$W4)ab$!9w^f`&Wowo_&VH*wv5RW)=eb?Dr9~Js&__
z`r3T(%h79fdk#CCZNypuf3iKBq1UH;IrJ8!!*Fi3`vU#-O#>MYBR7F_k<UemNl3nW
zwb{Z5xV{Fr)mlWL`=43}pX|Q{V`-WpwC7hA!l#P+eS~#ggt{KWEb4JZM%iY*9pNF+
z0&><GZH7mo_N_i*TI_?684R32(I~CS&t9i3Hm@v38r!2T0}>2uB@4>+U)c1R=K7N2
zB8|=UAt1rP@nk_+yz{4UI?r2PR9vJ1m+{UU^^$XL5E|&>&AG19U9VR;t7)$6F`5T6
zwXwGOFizNWuAD2)ITs6Y(98=FM>seC$Mg5DoO7=bG{56f&>=4Pb1pOFv0Uy9K+g40
zm$EK?N`N?+nzAmb=|y&%)#`$a2SMYnE+|WLG5?t^rlwZ{wl$S4G&Q|S&~S(7bxvqi
z`NZS;D>c1Z&^&{PcDJhNDxoRf-^35TOXw=0DZQ4mHvL)=GPZ2yT8kN<L|sIfS;Jw@
zC<B2%GrN?JFhhs)=N5u29u6~BX&PR`GPjjR7&n*&OC!h_;xJQ|fgsv2vzCX%BD|*l
z9@_08A{U9n+*}&ryu-|01_CbT^)e8&nOVOK1TADvFav?6%owH-uD+O0%tx5^$YG8<
zjc`52JboS`k~cZb0q7$U&LGTP>><OOd7p%N1vSFAn3#LeKtRL%gc{-VIOZ@k5YRBs
zp+<N=fw>TUMBMv&$VQ+SGhul&urut#Y|Rp(k1&fQGckHJ$afRQy&DT*zca6+reQBL
z1EiKS0y)e@scHDckohVN1YFE)X&`71vtMci$$}ha&XfpSScD8_@APSyV#v9}LU^Bq
zxj;1yTgZH&8bOjHhj~Xeg4{w5GoTs>+QW>g9s-Mji#e}-B+UDnR~X1JlP)3Gnx+wn
znUJf}LL!LR1_H_O%$<fDB>w_3Zy>`_-c{p0U$1r`sGT`!4Ft6_hpk39zcc5pfj}?j
z$TbkOhdFgMLK`v%uYsWU^K1mQGo!CT13Aq7s}ZE%a+n|3Kp>epgf+saz|2K#AmGZ{
z2zq(5g>alQ2eRhksN@?_27>l5hqFeIjLc!qX9Gc9%n0ox!?Y^jT+|4o7T<k05XcD{
zh)CAvd;#;IM*{?Uai@fbAQ2l7W{xos==DALwMKZq?qLIgZ$OKkM#P3>AZvZ!Fy}AI
zk@MH=8hrGNH&cgJ$-4AR%^5;-J>p$B3QlwW`Untv{*v>KIe%RvXt*0|HQvn%{BU;v
z%K7V~f@U==j(?(D<ImJPFuGZ;!Thx<@CMpSSwqLeWTKdwvM#CV2`8!3l19zc)A%N6
z{F$1vG*@@P;xg7G*W!e&scfOL#&+_3OwiQ%(JIr>pdofOPPM0-OS6lO#pWco>M4+k
zqk2n=>YGThB=<;39to%oQ4$h6sN_c<?=5upHd@FGwSY-~p0WkfZO$QIRJ%K~xYNQG
zoOryEavR~1WTKwWWwRxBuh>2n4<!<=cQTsE7iyJcJ?rl2^{1>;v0AxWD3=pScVWKS
zYTM^ZwPY@zEf(GRrEY7{K36EFi-}Y&?auc*-DT%WsbaEHE)?9Eesg}O%~wlTYlUp3
z?5=EPtXN6cGudj%ZFLv>vo>Eckt~*KxuiQe+wAVL&((^VYA%sXxXp!Dr(>Th6e{@?
z)OVY+$j)V-t7cNAVxp3Am*(f&efwOYUd+_X`La9P+q2?aB2&s25>?2Y-`SLWjauF4
zAZ%f2>~15IR<G-ILNe>3hw_O;KIul|(O5hd9*U2q+pYH8Bq|t<gu}y1lyI_6ce<yX
zX?kfEJ0|_FtzLJ!GvhQ`JKL>YYR8XPODgHsQq_9CT&ucEU2I0|&2*7sYbqXV?QHg&
zE$qIH$EJI5)jbRGSUlqU2%48I)UxGtIqk+Ht$3`t7>{9VXFS%Mj>nJ@jr(>j6Qv7o
zzF4a#YsHFNPmN{bv8i4gLc2Y1F2JO{K0d@F<#?F?&C36(y2gx~EEMbMOs<3)|ECHY
zorQ+j%Zg-Z*v^Damk$1KdSB!@e<-99ZY`65M<lDROvo0GE%tix*korW9_w_`m{7iq
zziK>o=~A=1*qQDu>)}++&6N}7a;B13BA^!rw=@RE5Uuz&l3b@D_xCPzVD{-w3)0cL
zsWx$Jlb!DDZBMEF%MzJHpX_QwA8}r$UjsF?ot<h-wj0=FytuCcsxB@7mcgC}$Plrx
zue*pmb;>Jr*l-%nsY{j?7GW{wb`!$q=CR$?ld2-fXf0Du)KmG2JJ(s@4rkgaRkXW2
z<>oTAS~gKkV>fJfs<Q|OZ_dVJGyUGuJbbK&Hgvi$)?BaOj>r7IPUYQNwUW(MGFex)
z13BhEkC;g=C>xK>_IeNjGqtBXnlbB^%jskxTgroRy4`Pg5v9<d^s{b!w7s{pu-HZb
zg2zq5OEqK0t>rW6WG+>77x$1HAr!TUmZE_>k^T;HcH*#rGdS<FCQEL<R;rfDS+Dou
zoYP|Dz#@fsC|ysXp%8+PwRkKN!v`bWCJSz*RxZ~onUdS-?rzR@IQ%?w39||z6c%1#
z<5bEmS8C}}5hECpRqU3>NbL7}{rGS^w$yF!oyQ(y>LSL1Zg$Eo)ROf=sp4V??i4*p
zJIN7awGjTDuBOZRbgJyawPv9H+j+MUGW=S=QAkx&iE3HvCN~|zknKyCWdCq%2yWL2
zWfO&RCLO|q&@En+N*3K*J_#F_lZaBgy1hN1uh+H}E&v-RKiOS&o6BxBT}#(<*{bW2
zB91i|g`(KeJqI@cW0Q^t1NbdY=iFK)Q%slPw2D#rf~bliOYo?W)kc%6wXsT~++dzk
zv>ThSLiq&jm1&G+QsZOW3bkqoZvl*eaJ-VtjAhb|+*obA4iF38P^Ov&VLg-B9*V^9
zR&l5{zP&!ay|JxO%?TOm6mA8EJUU(hgb=hd9u@0Oq_$_+0KD7KXfzf$emjT;tzK_e
z2hS)>NK6Itgd1g`kVCxRo@wv(td5a@v0G18Y9-8Sy<L-SI0@Vc_HOq%lBH9N_{~V=
zTM(nSR8N%isd@sD8on<`xZc@AH)LlolZQZvnC)jz;1|8|-;0HPK%(mQ6n({8N6Dr;
zA<ij{%-C3M4A$H}J_ehQ;$DRcSIL@NNhUItDgwjX3=;-jI5p<rX|&REq-4%5=97sW
zRuphPachNI%)<$~hzARB2x~NF-AXlCN@r^BbQ56{q#RW<ZNwbB+0g6nv&pM&v6#pq
z)FlwGW|n4~m?|)2`^f1aOf04%pcr&kH8mH@m|Ph%uxmCY)<x<9St)9rYPaWS?Fup7
z<!aSzxs=B`=D(ZqmxV8@W-J*h)ncw($!7l_0@4-j9!WP-trZLP+W(oq?lULLm>IIA
zR0Yeh)+`pg{=|c23QT82TtD!cc0(wu=W6L(JqO=Z(RmC#Z?KA$CPw)jW<jh1;1_ZM
z)SmKNkt!i%V<^|FDLwrm_9C;X3NZ0dwn|3Gm0=NK0?{P1ZCl~|OlUZaH*UNjao%{M
zy1kGsAS@&?hD(|4+d!}d1DuheR^N{J0b~d_!#roMA|7HrUB$>WMx(Fr^65t^YEC(@
zA{N%QdMV-JS^~`!lbyHxS<(HR#Z2}*Vrw;>sn!dwTt|2_&hnb;HebQ5mJ_97xt`Q!
z6Em8}hd{)*EV&R@tBq~-Osb%Qs|;|%VZ0V*$J|ler0{H0a;xyIRJug>QgemO>%t`+
zM5hWEu~?~K{;@Aa;G^kEB~i^{8IK7OE}+)ravdiZt%OB9W6bm&f-_VNj+sqlT+Y2B
zKMaEe0+tAw@mO`dj8!D9DDTf=fi>*~bY`Uv4f9n|72#FZYhc)%qA)SNAhkB4yIApy
IWI6BnFQ{(h!2kdN

literal 0
HcmV?d00001

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

literal 0
HcmV?d00001

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