diff --git a/tools/gamedata md5/Makefile b/tools/gamedata md5/Makefile
new file mode 100644
index 00000000..a73b8558
--- /dev/null
+++ b/tools/gamedata md5/Makefile	
@@ -0,0 +1,74 @@
+# (C)2004-2008 SourceMod Development Team
+# Makefile written by David "BAILOPAN" Anderson
+
+
+#####################################
+### EDIT BELOW FOR OTHER PROJECTS ###
+#####################################
+
+OBJECTS = main.cpp TextParsers.cpp sm_memtable.cpp md5.cpp
+
+##############################################
+### CONFIGURE ANY OTHER FLAGS/OPTIONS HERE ###
+##############################################
+
+C_OPT_FLAGS = -DNDEBUG -O3 -funroll-loops -pipe -fno-strict-aliasing
+C_DEBUG_FLAGS = -D_DEBUG -DDEBUG -g -ggdb3
+C_GCC4_FLAGS = -fvisibility=hidden
+CPP_GCC4_FLAGS = -fvisibility-inlines-hidden
+CPP = gcc-4.1
+
+BINARY = gamedatamd5
+
+INCLUDE += -I. -I../../public -I../../public/sourcepawn
+
+CFLAGS += -D_LINUX -Dstricmp=strcasecmp -D_stricmp=strcasecmp -D_strnicmp=strncasecmp -Dstrnicmp=strncasecmp \
+	-D_snprintf=snprintf -D_vsnprintf=vsnprintf -D_alloca=alloca -Dstrcmpi=strcasecmp -Wall -Werror \
+	-Wno-uninitialized -mfpmath=sse -msse -DHAVE_STDINT_H -DSM_DEFAULT_THREADER -m32
+CPPFLAGS += -Wno-non-virtual-dtor -fno-exceptions -fno-rtti
+
+################################################
+### DO NOT EDIT BELOW HERE FOR MOST PROJECTS ###
+################################################
+
+ifeq "$(DEBUG)" "true"
+	BIN_DIR = Debug
+	CFLAGS += $(C_DEBUG_FLAGS)
+else
+	BIN_DIR = Release
+	CFLAGS += $(C_OPT_FLAGS)
+endif
+
+GCC_VERSION := $(shell $(CPP) -dumpversion >&1 | cut -b1)
+ifeq "$(GCC_VERSION)" "4"
+	CFLAGS += $(C_GCC4_FLAGS)
+	CPPFLAGS += $(CPP_GCC4_FLAGS)
+endif
+
+OBJ_LINUX := $(OBJECTS:%vm_engine.cpp=$(BIN_DIR)/%vm_engine.o)
+OBJ_LINUX := $(OBJ_LINUX:%.cpp=$(BIN_DIR)/%.o)
+OBJ_LINUX := $(OBJ_LINUX:%.c=$(BIN_DIR)/%.o)
+
+$(BIN_DIR)/%vm_engine.o: %vm_engine.cpp
+	$(CPP) $(CFLAGS) $(CPPFLAGS) -o $@ -c $<
+
+$(BIN_DIR)/%.o: %.cpp
+	$(CPP) $(INCLUDE) $(CFLAGS) $(CPPFLAGS) -o $@ -c $<
+
+$(BIN_DIR)/%.o: %.c
+	$(CPP) $(INCLUDE) $(CFLAGS) -o $@ -c $<
+
+all:
+	mkdir -p $(BIN_DIR)
+	$(MAKE) -f Makefile sourcemod
+
+sourcemod: $(OBJ_LINUX)
+	$(CPP) $(INCLUDE) $(OBJ_LINUX) $(LINK) -m32 -lstdc++ -o$(BIN_DIR)/$(BINARY)
+
+debug:
+	$(MAKE) -f Makefile all DEBUG=true
+
+default: all
+
+clean:
+	rm -rf $(BIN_DIR)/$(BINARY)
diff --git a/tools/gamedata md5/TextParsers.cpp b/tools/gamedata md5/TextParsers.cpp
new file mode 100644
index 00000000..c39862c5
--- /dev/null
+++ b/tools/gamedata md5/TextParsers.cpp	
@@ -0,0 +1,1082 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include <wctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "TextParsers.h"
+//#include "ShareSys.h"
+//#include "sm_stringutil.h"
+//#include "LibrarySys.h"
+
+TextParsers g_TextParser;
+ITextParsers *textparsers = &g_TextParser;
+
+static int g_ini_chartable1[255] = {0};
+static int g_ws_chartable[255] = {0};
+
+bool TextParsers::IsWhitespace(const char *stream)
+{
+	return g_ws_chartable[(unsigned)*stream] == 1;
+}
+
+TextParsers::TextParsers()
+{
+	g_ini_chartable1[(unsigned)'_'] = 1;
+	g_ini_chartable1[(unsigned)'-'] = 1;
+	g_ini_chartable1[(unsigned)','] = 1;
+	g_ini_chartable1[(unsigned)'+'] = 1;
+	g_ini_chartable1[(unsigned)'.'] = 1;
+	g_ini_chartable1[(unsigned)'$'] = 1;
+	g_ini_chartable1[(unsigned)'?'] = 1;
+	g_ini_chartable1[(unsigned)'/'] = 1;
+	g_ws_chartable[(unsigned)'\n'] = 1;
+	g_ws_chartable[(unsigned)'\v'] = 1;
+	g_ws_chartable[(unsigned)'\r'] = 1;
+	g_ws_chartable[(unsigned)'\t'] = 1;
+	g_ws_chartable[(unsigned)'\f'] = 1;
+	g_ws_chartable[(unsigned)' '] = 1;
+}
+
+unsigned int TextParsers::GetUTF8CharBytes(const char *stream)
+{
+	return _GetUTF8CharBytes(stream);
+}
+
+/**
+ * Character streams
+ */
+
+struct CharStream
+{
+	const char *curpos;
+};
+
+bool CharStreamReader(void *stream, char *buffer, size_t maxlength, unsigned int *read)
+{
+	CharStream *srdr = (CharStream *)stream;
+
+	const char *ptr = srdr->curpos;
+	for (size_t i=0; i<maxlength; i++)
+	{
+		if (*ptr == '\0')
+		{
+			break;
+		}
+		*buffer++ = *ptr++;
+	}
+
+	*read = ptr - srdr->curpos;
+
+	srdr->curpos = ptr;
+
+	return true;
+}
+
+SMCError TextParsers::ParseString_SMC(const char *stream, 
+					 ITextListener_SMC *smc,
+					 SMCStates *states)
+{
+	CharStream srdr = { stream };
+
+	return ParseStream_SMC(&srdr, CharStreamReader, smc, states);
+}
+
+/**
+ * File streams
+ */
+
+bool FileStreamReader(void *stream, char *buffer, size_t maxlength, unsigned int *read)
+{
+	size_t num = fread(buffer, 1, maxlength, (FILE *)stream);
+
+	*read = static_cast<unsigned int>(num);
+
+	if (num == 0 && feof((FILE *)stream))
+	{
+		return true;
+	}
+
+	return (ferror((FILE *)stream) == 0);
+}
+
+SMCError TextParsers::ParseFile_SMC(const char *file, ITextListener_SMC *smc, SMCStates *states)
+{
+	FILE *fp = fopen(file, "rt");
+
+	if (!fp)
+	{
+		if (states != NULL)
+		{
+			states->line = 0;
+			states->col = 0;
+		}
+		return SMCError_StreamOpen;
+	}
+
+	SMCError result = ParseStream_SMC(fp, FileStreamReader, smc, states);
+
+	fclose(fp);
+
+	return result;
+}
+
+SMCError TextParsers::ParseSMCFile(const char *file,
+								   ITextListener_SMC *smc_listener,
+								   SMCStates *states,
+								   char *buffer,
+								   size_t maxsize)
+{
+	const char *errstr;
+	FILE *fp = fopen(file, "rt");
+
+	if (fp == NULL)
+	{
+		char error[256] = "unknown";
+		if (states != NULL)
+		{
+			states->line = 0;
+			states->col = 0;
+		}
+		//g_LibSys.GetPlatformError(error, sizeof(error));
+		UTIL_Format(buffer, maxsize, "File could not be opened: %s", error);
+		return SMCError_StreamOpen;
+	}
+
+	SMCError result = ParseStream_SMC(fp, FileStreamReader, smc_listener, states);
+
+	fclose(fp);
+
+	errstr = GetSMCErrorString(result);
+	UTIL_Format(buffer, maxsize, "%s", errstr != NULL ? errstr : "Unknown error");
+
+	return result;
+}
+
+/** 
+ * Raw parsing of streams with helper functions
+ */
+
+struct StringInfo
+{
+	StringInfo() : quoted(false), ptr(NULL), end(NULL), special(false) { }
+	bool quoted;
+	char *ptr;
+	char *end;
+	bool special;
+};
+
+const char *FixupString(StringInfo &data)
+{
+	if (!data.ptr)
+	{
+		return NULL;
+	}
+
+	if (data.quoted)
+	{
+		data.ptr++;
+	}
+#if defined _DEBUG
+	else {
+		/* A string will never have beginning whitespace because we ignore it in the stream.
+		 * Furthermore, if there is trailing whitespace, the end ptr will point to it, so it is valid
+		 * to overwrite!  Lastly, the last character must be whitespace or a comment/invalid character.
+		 */
+ 	}
+#endif
+
+	/* Do some extra work on strings that have special quoted characters. */
+	if (data.special)
+	{
+		char *outptr = data.ptr;
+		size_t len = data.end - data.ptr;
+		if (len >= 2)
+		{
+			for (size_t i=0; i<len; i++)
+			{
+				if (data.ptr[i] == '\\' && i < len - 1)
+				{
+					/* Resolve the next character. */
+					i++;
+					if (data.ptr[i] == 'n')
+					{
+						data.ptr[i] = '\n';
+					} else if (data.ptr[i] == 't') {
+						data.ptr[i] = '\t';
+					} else if (data.ptr[i] == 'r') {
+						data.ptr[i] = '\r';
+					} else if (data.ptr[i] != '\\'
+						&& data.ptr[i] != '"') {
+						/* This character is invalid, so go back one */
+						i--;
+					}
+				}
+				*outptr++ = data.ptr[i];
+			}
+			*outptr = '\0';
+		}
+	}
+
+	if (data.end)
+	{
+		*(data.end) = '\0';
+	}
+
+	return data.ptr;
+}
+
+const char *rotate(StringInfo info[3])
+{
+	if (info[2].ptr != NULL)
+	{
+		return info[2].ptr;
+	}
+
+	if (info[0].ptr != NULL)
+	{
+		info[2] = info[1];
+		info[1] = info[0];
+		info[0] = StringInfo();
+	}
+	
+	return NULL;
+}
+
+void scrap(StringInfo info[3])
+{
+	info[2] = StringInfo();
+	info[1] = StringInfo();
+	info[0] = StringInfo();
+}
+
+void reloc(StringInfo &data, unsigned int bytes)
+{
+	if (data.ptr)
+	{
+		data.ptr -= bytes;
+	}
+	if (data.end)
+	{
+		data.end -= bytes;
+	}
+}
+
+char *lowstring(StringInfo info[3])
+{
+	for (int i=2; i>=0; i--)
+	{
+		if (info[i].ptr)
+		{
+			return info[i].ptr;
+		}
+	}
+
+	return NULL;
+}
+
+SMCError TextParsers::ParseStream_SMC(void *stream, 
+								   STREAMREADER srdr, 
+								   ITextListener_SMC *smc, 
+								   SMCStates *pStates)
+{
+	char *reparse_point = NULL;
+	char in_buf[4096];
+	char *parse_point = in_buf;
+	char *line_begin = in_buf;
+	unsigned int read;
+	unsigned int curlevel = 0;
+	bool in_quote = false;
+	bool ignoring = false;
+	bool eol_comment = false;
+	bool ml_comment = false;
+	unsigned int i;
+	SMCError err = SMCError_Okay;
+	SMCResult res;
+	SMCStates states;
+	char c;
+
+	StringInfo strings[3];
+	StringInfo emptystring;
+
+	states.line = 1;
+	states.col = 0;
+
+	smc->ReadSMC_ParseStart();
+
+	/**
+	 * The stream reader reads in as much as it can fill the buffer with.
+	 * It then processes the buffer.  If the buffer cannot be fully processed, for example, 
+	 * a line is left hanging with no newline, then the contents of the buffer is shifted 
+	 * down, and the buffer is filled from the stream reader again.
+	 *
+	 * What makes this particularly annoying is that we cache pointers everywhere, so when 
+	 * the shifting process takes place, all those pointers must be shifted as well.
+	 */
+	while (srdr(stream, parse_point, sizeof(in_buf) - (parse_point - in_buf) - 1, &read))
+	{
+		if (!read)
+		{
+			break;
+		}
+
+		/* Check for BOM markings, which is only relevant on the first line.
+		 * Not worth it, but it could be moved out of the loop.
+		 */
+		if (states.line == 1 && 
+			in_buf[0] == (char)0xEF && 
+			in_buf[1] == (char)0xBB && 
+			in_buf[2] == (char)0xBF)
+		{
+			/* Move EVERYTHING down :\ */
+			memmove(in_buf, &in_buf[3], read - 3);
+			read -= 3;
+		}
+
+		if (reparse_point)
+		{
+			read += (parse_point - reparse_point);
+			parse_point = reparse_point;
+			reparse_point = NULL;
+		}
+
+		for (i=0; i<read; i++)
+		{
+			c = parse_point[i];
+			if (c == '\n')
+			{
+				/* If we got a newline, there's a lot of things that could have happened in the interim.
+				 * First, let's make sure the staged strings are rotated.
+				 */
+				if (strings[0].ptr)
+				{
+					strings[0].end = &parse_point[i];
+					if (rotate(strings) != NULL)
+					{
+						err = SMCError_InvalidTokens;
+						goto failed;
+					}
+				}
+
+				/* Next, let's clear some line-based values that may no longer have meaning */
+				eol_comment = false;
+				in_quote = false;
+				if (ignoring && !ml_comment)
+				{
+					ignoring = false;
+				}
+
+				/* Pass the raw line onto the listener.  We terminate the line so the receiver 
+				 * doesn't get tons of useless info.  We restore the newline after.
+				 */
+				parse_point[i] = '\0';
+				if ((res=smc->ReadSMC_RawLine(&states, line_begin)) != SMCResult_Continue)
+				{
+					err = (res == SMCResult_HaltFail) ? SMCError_Custom : SMCError_Okay;
+					goto failed;
+				}
+				parse_point[i] = '\n';
+
+				/* Now we check the sanity of our staged strings! */
+				if (strings[2].ptr)
+				{
+					if (!curlevel)
+					{
+						err = SMCError_InvalidProperty1;
+						goto failed;
+					}
+					/* Assume the next string is a property and pass the info on. */
+					if ((res=smc->ReadSMC_KeyValue(
+						&states,
+						FixupString(strings[2]),
+						FixupString(strings[1]))) != SMCResult_Continue)
+					{
+						err = (res == SMCResult_HaltFail) ? SMCError_Custom : SMCError_Okay;
+						goto failed;
+					}
+					scrap(strings);
+				}
+
+				/* Change the states for the next line */
+				states.col = 0;
+				states.line++;
+				line_begin = &parse_point[i+1];		//Note: safe because this gets relocated later
+			} 
+			else if (ignoring) 
+			{
+				if (in_quote)
+				{
+					/* If i was 0, we could have reparsed, so make sure there's no buffer underrun */
+					if ((&parse_point[i] != in_buf) && c == '"' && parse_point[i-1] != '\\')
+					{
+						/* If we reached a quote in an ignore phase,
+						 * we're staging a string and we must rotate it out.
+						 */
+						in_quote = false;
+						ignoring = false;
+						/* Set our info */
+						strings[0].end = &parse_point[i];
+						strings[0].quoted = true;
+						if (rotate(strings) != NULL)
+						{
+							/* If we rotated too many strings, there was too much crap on one line */
+							err = SMCError_InvalidTokens;
+							goto failed;
+						}
+					} 
+					else if (c == '\\') 
+					{
+						strings[0].special = true;
+						if (i == (read - 1))
+						{
+							reparse_point = &parse_point[i];
+							break;
+						}
+					}
+				} 
+				else if (ml_comment) 
+				{
+					if (c == '*')
+					{
+						/* Check if we need to get more input first */
+						if (i == read - 1)
+						{
+							reparse_point = &parse_point[i];
+							break;
+						}
+						if (parse_point[i+1] == '/')
+						{
+							ml_comment = false;
+							ignoring = false;
+							/* We should not be staging anything right now. */
+							assert(strings[0].ptr == NULL);
+							/* Advance the input stream so we don't choke on this token */
+							i++;
+							states.col++;
+						}
+					}
+				}
+			} 
+			else 
+			{
+				/* Check if we're whitespace or not */
+				if (!g_ws_chartable[(unsigned)c])
+				{
+					bool restage = false;
+					/* Check various special tokens:
+					 * ;
+					 * //
+					 * / *
+					 * {
+					 * }
+					 */
+					if (c == ';' || c == '/')
+					{
+						/* If it's a line-based comment (that is, ; or //)
+						 * we will need to scrap everything until the end of the line.
+						 */
+						if (c == '/')
+						{
+							if (i == read - 1)
+							{
+								/* If we reached the end of the look-ahead, we need to re-check our input.
+								 * Breaking out will force this to be the new reparse point!
+								 */
+								reparse_point = &parse_point[i];
+								break;
+							}
+							if (parse_point[i + 1] == '/')
+							{
+								/* standard comment */
+								ignoring = true;
+								eol_comment = true;
+								restage = true;
+							} 
+							else if (parse_point[i+1] == '*') 
+							{
+								/* inline comment - start ignoring */
+								ignoring = true;
+								ml_comment = true;
+								/* yes, we restage, meaning that:
+								 * STR/ *stuff* /ING  (space because ml comments don't nest in C++)
+								 * will not generate 'STRING', but rather 'STR' and 'ING'.
+								 * This should be a rare occurrence and is done here for convenience.
+								 */
+								restage = true;
+							}
+						} 
+						else 
+						{
+							ignoring = true;
+							eol_comment = true;
+							restage = true;
+						}
+					} 
+					else if (c == '{') 
+					{
+						/* If we are staging a string, we must rotate here */
+						if (strings[0].ptr)
+						{
+							/* We have unacceptable tokens on this line */
+							if (rotate(strings) != NULL)
+							{
+								err = SMCError_InvalidSection1;
+								goto failed;
+							}
+						}
+						/* Sections must always be alone */
+						if (strings[2].ptr != NULL)
+						{
+							err = SMCError_InvalidSection1;
+							goto failed;
+						} 
+						else if (strings[1].ptr == NULL)
+						{
+							err = SMCError_InvalidSection2;
+							goto failed;
+						}
+						if ((res=smc->ReadSMC_NewSection(&states, FixupString(strings[1])))
+							!= SMCResult_Continue)
+						{
+							err = (res == SMCResult_HaltFail) ? SMCError_Custom : SMCError_Okay;
+							goto failed;
+						}
+						strings[1] = emptystring;
+						curlevel++;
+					} 
+					else if (c == '}') 
+					{
+						/* Unlike our matching friend, this can be on the same line as something prior */
+						if (rotate(strings) != NULL)
+						{
+							err = SMCError_InvalidSection3;
+							goto failed;
+						}
+						if (strings[2].ptr)
+						{
+							if (!curlevel)
+							{
+								err = SMCError_InvalidProperty1;
+								goto failed;
+							}
+							if ((res=smc->ReadSMC_KeyValue(
+											&states,
+											FixupString(strings[2]),
+											FixupString(strings[1])))
+								!= SMCResult_Continue)
+							{
+								err = (res == SMCResult_HaltFail) ? SMCError_Custom : SMCError_Okay;
+								goto failed;
+							}
+						} 
+						else if (strings[1].ptr) 
+						{
+							err = SMCError_InvalidSection3;
+							goto failed;
+						} 
+						else if (!curlevel) 
+						{
+							err = SMCError_InvalidSection4;
+							goto failed;
+						}
+						/* Now it's safe to leave the section */
+						scrap(strings);
+						if ((res=smc->ReadSMC_LeavingSection(&states)) != SMCResult_Continue)
+						{
+							err = (res == SMCResult_HaltFail) ? SMCError_Custom : SMCError_Okay;
+							goto failed;
+						}
+						curlevel--;
+					} 
+					else if (c == '"') 
+					{
+						/* If we get a quote mark, we always restage, but we need to do it beforehand */
+						if (strings[0].ptr)
+						{
+							strings[0].end = &parse_point[i];
+							if (rotate(strings) != NULL)
+							{
+								err = SMCError_InvalidTokens;
+								goto failed;
+							}
+						}
+						strings[0].ptr = &parse_point[i];
+						in_quote = true;
+						ignoring = true;
+					} 
+					else if (!strings[0].ptr) 
+					{
+						/* If we have no string, we must start one */
+						strings[0].ptr = &parse_point[i];
+					}
+					if (restage && strings[0].ptr)
+					{
+						strings[0].end = &parse_point[i];
+						if (rotate(strings) != NULL)
+						{
+							err = SMCError_InvalidTokens;
+							goto failed;
+						}
+					}
+				} 
+				else 
+				{
+					/* If we're eating a string and get whitespace, we need to restage.
+					 * (Note that if we are quoted, this is being ignored)
+					 */
+					if (strings[0].ptr)
+					{
+						/*
+						 * The specification says the second string in a pair does not need to be quoted.
+						 * Thus, we check if there's already a string on the stack.
+						 * If there's a newline, we always rotate so the newline has an empty starter.
+						 */
+						if (!strings[1].ptr)
+						{
+							/* There's no string, so we must move this one down and eat up another */
+							strings[0].end = &parse_point[i];
+							rotate(strings);
+						} 
+						else if (!strings[1].quoted) 
+						{
+							err = SMCError_InvalidTokens;
+							goto failed;
+						}
+					}
+				}
+			}
+
+			/* Advance which token we're on */
+			states.col++;
+		}
+
+		if (line_begin != in_buf)
+		{
+			/* The line buffer has advanced, so it's safe to copy N bytes back to the beginning.
+			 * What's N?  N is the lowest point we're currently relying on.
+			 */
+			char *stage = lowstring(strings);
+			if (!stage || stage > line_begin)
+			{
+				stage = line_begin;
+			}
+			unsigned int bytes = read - (stage - parse_point);
+
+			/* It is now safe to delete everything before the staged point */
+			memmove(in_buf, stage, bytes);
+
+			/* Calculate the number of bytes in the new buffer */
+			bytes = stage - in_buf;
+			/* Relocate all the cached pointers to our new base */
+			line_begin -= bytes;
+			reloc(strings[0], bytes);
+			reloc(strings[1], bytes);
+			reloc(strings[2], bytes);
+			if (reparse_point)
+			{
+				reparse_point -= bytes;
+			}
+			if (parse_point)
+			{
+				parse_point = &parse_point[read];
+				parse_point -= bytes;
+			}
+		} 
+		else if (read == sizeof(in_buf) - 1) 
+		{
+			err = SMCError_TokenOverflow;
+			goto failed;
+		}
+	}
+
+	/* If we're done parsing and there are tokens left over... */
+	if (curlevel)
+	{
+		err = SMCError_InvalidSection5;
+		goto failed;
+	} 
+	else if (strings[0].ptr || strings[1].ptr) 
+	{
+		err = SMCError_InvalidTokens;
+		goto failed;
+	}
+	
+	smc->ReadSMC_ParseEnd(false, false);
+	
+	if (pStates != NULL)
+	{
+		*pStates = states;
+	}
+
+	return SMCError_Okay;
+
+failed:
+	if (pStates != NULL)
+	{
+		*pStates = states;
+	}
+
+	smc->ReadSMC_ParseEnd(true, (err == SMCError_Custom));
+
+	return err;
+}
+
+
+/**
+ * INI parser 
+ */
+
+bool TextParsers::ParseFile_INI(const char *file, ITextListener_INI *ini_listener, unsigned int *line, unsigned int *col)
+{
+	FILE *fp = fopen(file, "rt");
+	unsigned int curline = 0;
+	unsigned int curtok;
+	size_t len;
+
+	if (!fp)
+	{
+		if (line)
+		{
+			*line = 0;
+		}
+
+		return false;
+	}
+
+	char buffer[2048];
+	char *ptr, *save_ptr;
+	bool in_quote;
+
+	while (!feof(fp))
+	{
+		curline++;
+		curtok = 0;
+		buffer[0] = '\0';
+		if (fgets(buffer, sizeof(buffer), fp) == NULL)
+		{
+			break;
+		}
+
+		//:TODO: this will only run once, so find a nice way to move it out of the while loop
+		/* If this is the first line, check the first three bytes for BOM */
+		if (curline == 1 && 
+			buffer[0] == (char)0xEF && 
+			buffer[1] == (char)0xBB && 
+			buffer[2] == (char)0xBF)
+		{
+			/* We have a UTF-8 marked file... skip these bytes */
+			ptr = &buffer[3];
+		} else {
+			ptr = buffer;
+		}
+
+		/***************************************************
+		 * We preprocess the string before parsing tokens! *
+		 ***************************************************/
+
+		/* First strip beginning whitespace */
+		while (*ptr != '\0' && g_ws_chartable[(unsigned)*ptr] != 0)
+		{
+			ptr++;
+		}
+
+		len = strlen(ptr);
+
+		if (!len)
+		{
+			continue;
+		}
+
+		/* Now search for comment characters */
+		in_quote = false;
+		save_ptr = ptr;
+		for (size_t i=0; i<len; i++,ptr++)
+		{
+			if (!in_quote)
+			{
+				switch (*ptr)
+				{
+				case '"':
+					{
+						in_quote = true;
+						break;
+					}
+				case ';':
+					{
+						/* Stop the loop */
+						len = i;
+						/* Terminate the string here */
+						*ptr = '\0';
+						break;
+					}
+				}
+			} else {
+				if (*ptr == '"')
+				{
+					in_quote = false;
+				}
+			}
+		}
+
+		if (!len)
+		{
+			continue;
+		}
+
+		ptr = save_ptr;
+
+		/* Lastly, strip ending whitespace off */
+		for (size_t i=len-1; i>=0 && i<len; i--)
+		{
+			if (g_ws_chartable[(unsigned)ptr[i]])
+			{
+				ptr[i] = '\0';
+				len--;
+			} else {
+				break;
+			}
+		}
+
+		if (!len)
+		{
+			continue;
+		}
+
+		if (!ini_listener->ReadINI_RawLine(ptr, &curtok))
+		{
+			goto event_failed;
+		}
+
+		if (*ptr == '[')
+		{
+			bool invalid_tokens = false;
+			bool got_bracket = false;
+			bool extra_tokens = false;
+			char c;
+			bool alnum;
+			wchar_t wc;
+
+			for (size_t i=1; i<len; i++)
+			{
+				c = ptr[i];
+				alnum = false;
+
+				if (c & (1<<7))
+				{
+					if (mbtowc(&wc, &ptr[i], len-i) != -1)
+					{
+						alnum = (iswalnum(wc) != 0);
+						i += _GetUTF8CharBytes(&ptr[i]) - 1;
+					}
+				} else {
+					alnum = (isalnum(c) != 0) || (g_ini_chartable1[(unsigned)c] != 0);
+				}
+				if (!alnum)
+				{
+					/* First check - is this a bracket? */
+					if (c == ']')
+					{
+						/* Yes! */
+						got_bracket = true;
+						/* If this isn't the last character... */
+						if (i != len - 1)
+						{
+							extra_tokens = true;
+						}
+						/* terminate */
+						ptr[i] = '\0';
+						break;
+					} else {
+						/* n...No! Continue copying. */
+						invalid_tokens = true;
+					}
+				}
+			}
+
+			/* Tell the handler */
+			if (!ini_listener->ReadINI_NewSection(&ptr[1], invalid_tokens, got_bracket, extra_tokens, &curtok))
+			{
+				goto event_failed;
+			}
+		} else {
+			char *key_ptr = ptr;
+			char *val_ptr = NULL;
+			char c;
+			size_t first_space = 0;
+			bool invalid_tokens = false;
+			bool equal_token = false;
+			bool quotes = false;
+			bool alnum;
+			wchar_t wc;
+
+			for (size_t i=0; i<len; i++)
+			{
+				c = ptr[i];
+				alnum = false;
+				/* is this an invalid char? */
+				if (c & (1<<7))
+				{
+					if (mbtowc(&wc, &ptr[i], len-i) != -1)
+					{
+						alnum = (iswalnum(wc) != 0);
+						i += _GetUTF8CharBytes(&ptr[i]) - 1;
+					}
+				} else {
+					alnum = (isalnum(c) != 0) || (g_ini_chartable1[(unsigned)c] != 0);
+				}
+
+				if (!alnum)
+				{
+					if (g_ws_chartable[(unsigned)c])
+					{
+						/* if it's a space, keep track of the first occurring space */
+						if (!first_space)
+						{
+							first_space = i;
+						}
+					} else {
+						if (c == '=')
+						{
+							/* if it's an equal sign, we're done with the key */
+							if (first_space)
+							{
+								/* remove excess whitespace */
+								key_ptr[first_space] = '\0';
+							} else {
+								/* remove the equal sign */
+								key_ptr[i] = '\0';
+							}
+							if (ptr[++i] != '\0')
+							{
+								/* If this isn't the end, set next pointer */
+								val_ptr = &ptr[i];
+							}
+							equal_token = true;
+							break;
+						} else {
+							/* Mark that we got something invalid! */
+							invalid_tokens = true;
+							first_space = 0;
+						}
+					}
+				}
+			}
+
+			/* Now we need to parse the value, if any */
+			if (val_ptr)
+			{
+				/* eat up spaces! there shouldn't be any h*/
+				while ((*val_ptr != '\0') && g_ws_chartable[(unsigned)*val_ptr] != 0)
+				{
+					val_ptr++;
+				}
+				if (*val_ptr == '\0')
+				{
+					val_ptr = NULL;
+					goto skip_value;
+				}
+				/* Do we have an initial quote? If so, the parsing rules change! */
+				if (*val_ptr == '"' && *val_ptr != '\0')
+				{
+					len = strlen(val_ptr);
+					if (val_ptr[len-1] == '"')
+					{
+						/* Strip quotes! */
+						val_ptr[--len] = '\0';
+						val_ptr++;
+						quotes = true;
+					}
+				}
+			}
+skip_value:
+			/* We're done! */
+			curtok = val_ptr - buffer;
+			if (!ini_listener->ReadINI_KeyValue(key_ptr, val_ptr, invalid_tokens, equal_token, quotes, &curtok))
+			{
+				curtok = 0;
+				goto event_failed;
+			}
+		}
+	}
+
+	if (line)
+	{
+		*line = curline;
+	}
+
+	fclose(fp);
+
+	return true;
+
+event_failed:
+	if (line)
+	{
+		*line = curline;
+	}
+
+	if (col)
+	{
+		*col = curtok;
+	}
+
+	fclose(fp);
+
+	return false;
+}
+
+const char *TextParsers::GetSMCErrorString(SMCError err)
+{
+	static const char *s_errors[] = 
+	{
+		NULL,
+		"Stream failed to open",
+		"Stream returned read error",
+		NULL,
+		"Un-quoted section has invalid tokens",
+		"Section declared without header",
+		"Section declared with unknown tokens",
+		"Section ending without a matching section beginning",
+		"Section beginning without a matching ending",
+		"Line contained too many invalid tokens",
+		"Token buffer overflowed",
+		"A property was declared outside of a section",
+	};
+
+	if (err < SMCError_Okay || err > SMCError_InvalidProperty1)
+	{
+		return NULL;
+	}
+
+	return s_errors[err];
+}
diff --git a/tools/gamedata md5/TextParsers.h b/tools/gamedata md5/TextParsers.h
new file mode 100644
index 00000000..44f9e70f
--- /dev/null
+++ b/tools/gamedata md5/TextParsers.h	
@@ -0,0 +1,87 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#ifndef _INCLUDE_SOURCEMOD_TEXTPARSERS_H_
+#define _INCLUDE_SOURCEMOD_TEXTPARSERS_H_
+
+#include "ITextParsers.h"
+#include "main.h"
+
+using namespace SourceMod;
+
+/**
+ * @param void *			IN: Stream pointer
+ * @param char *			IN/OUT: Stream buffer
+ * @param size_t			IN: Maximum size of buffer
+ * @param unsigned int *	OUT: Number of bytes read (0 = end of stream)
+ * @return					True on success, false on failure
+ */
+typedef bool (*STREAMREADER)(void *, char *, size_t, unsigned int *);
+
+class TextParsers : public ITextParsers
+{
+public:
+	TextParsers();
+public:
+	bool ParseFile_INI(const char *file, 
+		ITextListener_INI *ini_listener,
+		unsigned int *line,
+		unsigned int *col);
+
+	SMCError ParseFile_SMC(const char *file, 
+		ITextListener_SMC *smc_listener, 
+		SMCStates *states);
+
+	SMCError ParseSMCFile(const char *file,
+			ITextListener_SMC *smc_listener,
+			SMCStates *states,
+			char *buffer,
+			size_t maxsize);
+
+	unsigned int GetUTF8CharBytes(const char *stream);
+
+	const char *GetSMCErrorString(SMCError err);
+	bool IsWhitespace(const char *stream);
+private:
+	SMCError ParseString_SMC(const char *stream, 
+		ITextListener_SMC *smc,
+		SMCStates *states);
+	SMCError ParseStream_SMC(void *stream, 
+		STREAMREADER srdr,
+		ITextListener_SMC *smc,
+		SMCStates *states);
+
+};
+
+extern TextParsers g_TextParser;
+
+#endif //_INCLUDE_SOURCEMOD_TEXTPARSERS_H_
+
diff --git a/tools/gamedata md5/main.cpp b/tools/gamedata md5/main.cpp
new file mode 100644
index 00000000..26da944f
--- /dev/null
+++ b/tools/gamedata md5/main.cpp	
@@ -0,0 +1,45 @@
+#include "main.h"
+#include <stdarg.h>
+
+BuildMD5ableBuffer g_MD5Builder;
+
+int main(int argc, char **argv)
+{
+	SMCStates states;
+	SMCError error;
+
+	if (argc < 2)
+	{
+		fprintf(stderr, "Usage: <file>\n");
+		return -1;
+	}
+
+	error = g_TextParser.ParseFile_SMC(argv[1], &g_MD5Builder, &states);
+
+	if (error == SMCError_Okay)
+	{
+		printf("MD5: %s\n", g_MD5Builder.GetMD5String());
+		return 0;
+	}
+
+	fprintf(stderr, "Failed to parse file, Error %i at line %i and col %i\n", error, states.line, states.col);
+	return -1;
+}
+
+size_t UTIL_Format(char *buffer, size_t maxlength, const char *fmt, ...)
+{
+	va_list ap;
+	va_start(ap, fmt);
+	size_t len = vsnprintf(buffer, maxlength, fmt, ap);
+	va_end(ap);
+
+	if (len >= maxlength)
+	{
+		buffer[maxlength - 1] = '\0';
+		return (maxlength - 1);
+	}
+	else
+	{
+		return len;
+	}
+}
diff --git a/tools/gamedata md5/main.h b/tools/gamedata md5/main.h
new file mode 100644
index 00000000..56682e2a
--- /dev/null
+++ b/tools/gamedata md5/main.h	
@@ -0,0 +1,88 @@
+#ifndef _INCLUDE_GAMEDATAMD5_MAIN_H_
+#define _INCLUDE_GAMEDATAMD5_MAIN_H_
+
+#include "TextParsers.h"
+#include "sm_memtable.h"
+#include "md5.h"
+
+using namespace SourceMod;
+
+size_t UTIL_Format(char *buffer, size_t maxlength, const char *fmt, ...);
+
+class BuildMD5ableBuffer : public ITextListener_SMC
+{
+public:
+
+	BuildMD5ableBuffer()
+	{
+		stringTable = new BaseStringTable(2048);
+		md5[0] = 0;
+		md5String[0] = 0;
+	}
+
+	~BuildMD5ableBuffer()
+	{
+		delete stringTable;
+	}
+
+	void ReadSMC_ParseStart()
+	{
+		checksum = MD5();
+	}
+
+	SMCResult ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value)
+	{
+		stringTable->AddString(key);
+		stringTable->AddString(value);
+
+		return SMCResult_Continue;
+	}
+
+	SMCResult ReadSMC_NewSection(const SMCStates *states, const char *name)
+	{
+		stringTable->AddString(name);
+
+		return SMCResult_Continue;
+	}
+
+	void ReadSMC_ParseEnd(bool halted, bool failed)
+	{
+		if (halted || failed)
+		{
+			return;
+		}
+
+		void *data = stringTable->GetMemTable()->GetAddress(0);
+
+		if (data != NULL)
+		{
+			checksum.update((unsigned char *)data, stringTable->GetMemTable()->GetActualMemUsed());
+		}
+
+		checksum.finalize();
+
+		checksum.hex_digest(md5String);
+		checksum.raw_digest(md5);
+
+		stringTable->Reset();
+	}
+
+	unsigned char * GetMD5()
+	{
+		return md5;
+	}
+
+	unsigned char * GetMD5String()
+	{
+		return (unsigned char *)&md5String[0];
+	}
+
+private:
+	MD5 checksum;
+	unsigned char md5[16];
+	char md5String[33];
+	BaseStringTable *stringTable;
+};
+
+
+#endif // _INCLUDE_GAMEDATAMD5_MAIN_H_
diff --git a/tools/gamedata md5/md5.cpp b/tools/gamedata md5/md5.cpp
new file mode 100644
index 00000000..a5c899ef
--- /dev/null
+++ b/tools/gamedata md5/md5.cpp	
@@ -0,0 +1,485 @@
+// MD5.CC - source code for the C++/object oriented translation and 
+//          modification of MD5.
+
+// Translation and modification (c) 1995 by Mordechai T. Abzug 
+
+// This translation/ modification is provided "as is," without express or 
+// implied warranty of any kind.
+
+// The translator/ modifier does not claim (1) that MD5 will do what you think 
+// it does; (2) that this translation/ modification is accurate; or (3) that 
+// this software is "merchantible."  (Language for this disclaimer partially 
+// copied from the disclaimer below).
+
+/* based on:
+
+   MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
+   MDDRIVER.C - test driver for MD2, MD4 and MD5
+
+
+   Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+rights reserved.
+
+License to copy and use this software is granted provided that it
+is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+Algorithm" in all material mentioning or referencing this software
+or this function.
+
+License is also granted to make and use derivative works provided
+that such works are identified as "derived from the RSA Data
+Security, Inc. MD5 Message-Digest Algorithm" in all material
+mentioning or referencing the derived work.
+
+RSA Data Security, Inc. makes no representations concerning either
+the merchantability of this software or the suitability of this
+software for any particular purpose. It is provided "as is"
+without express or implied warranty of any kind.
+
+These notices must be retained in any copies of any part of this
+documentation and/or software.
+
+ */
+
+#include "md5.h"
+
+#include <assert.h>
+#include <string.h>
+
+// MD5 simple initialization method
+
+MD5::MD5(){
+
+  init();
+
+}
+
+
+// MD5 block update operation. Continues an MD5 message-digest
+// operation, processing another message block, and updating the
+// context.
+
+void MD5::update (uint1 *input, uint4 input_length) {
+
+  uint4 input_index, buffer_index;
+  uint4 buffer_space;                // how much space is left in buffer
+
+  if (finalized){  // so we can't update!
+    /*cerr << "MD5::update:  Can't update a finalized digest!" << endl;*/
+    return;
+  }
+
+  // Compute number of bytes mod 64
+  buffer_index = (unsigned int)((count[0] >> 3) & 0x3F);
+
+  // Update number of bits
+  if (  (count[0] += ((uint4) input_length << 3))<((uint4) input_length << 3) )
+    count[1]++;
+
+  count[1] += ((uint4)input_length >> 29);
+
+
+  buffer_space = 64 - buffer_index;  // how much space is left in buffer
+
+  // Transform as many times as possible.
+  if (input_length >= buffer_space) { // ie. we have enough to fill the buffer
+    // fill the rest of the buffer and transform
+    memcpy (buffer + buffer_index, input, buffer_space);
+    transform (buffer);
+
+    // now, transform each 64-byte piece of the input, bypassing the buffer
+    for (input_index = buffer_space; input_index + 63 < input_length; 
+	 input_index += 64)
+      transform (input+input_index);
+
+    buffer_index = 0;  // so we can buffer remaining
+  }
+  else
+    input_index=0;     // so we can buffer the whole input
+
+
+  // and here we do the buffering:
+  memcpy(buffer+buffer_index, input+input_index, input_length-input_index);
+}
+
+
+
+// MD5 update for files.
+// Like above, except that it works on files (and uses above as a primitive.)
+
+void MD5::update(FILE *file){
+
+  unsigned char buffer[1024];
+  int len;
+
+  while ((len=fread(buffer, 1, 1024, file)))
+    update(buffer, len);
+
+  fclose (file);
+
+}
+
+
+// MD5 finalization. Ends an MD5 message-digest operation, writing the
+// the message digest and zeroizing the context.
+
+
+void MD5::finalize (){
+
+  unsigned char bits[8];
+  unsigned int index, padLen;
+  static uint1 PADDING[64]={
+    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+
+  if (finalized){
+   /* cerr << "MD5::finalize:  Already finalized this digest!" << endl;*/
+    return;
+  }
+
+  // Save number of bits
+  encode (bits, count, 8);
+
+  // Pad out to 56 mod 64.
+  index = (uint4) ((count[0] >> 3) & 0x3f);
+  padLen = (index < 56) ? (56 - index) : (120 - index);
+  update (PADDING, padLen);
+
+  // Append length (before padding)
+  update (bits, 8);
+
+  // Store state in digest
+  encode (digest, state, 16);
+
+  // Zeroize sensitive information
+  memset (buffer, 0, sizeof(*buffer));
+
+  finalized=1;
+
+}
+
+
+
+
+MD5::MD5(FILE *file){
+
+  init();  // must be called be all constructors
+  update(file);
+  finalize ();
+}
+
+unsigned char *MD5::raw_digest(){
+
+  uint1 *s = new uint1[16];
+
+  if (!finalized){
+/*    cerr << "MD5::raw_digest:  Can't get digest if you haven't "<<
+      "finalized the digest!" <<endl;*/
+    return ( (unsigned char*) "");
+  }
+
+  memcpy(s, digest, 16);
+  return s;
+}
+
+unsigned char *MD5::raw_digest(unsigned char buffer[16])
+{
+	if (!finalized)
+	{
+		return ( (unsigned char*) "");
+	}
+
+	 memcpy(buffer, digest, 16);
+	 return buffer;
+}
+
+
+
+char *MD5::hex_digest(){
+
+  int i;
+  char *s= new char[33];
+
+  if (!finalized){
+/*    cerr << "MD5::hex_digest:  Can't get digest if you haven't "<<
+      "finalized the digest!" <<endl;*/
+    return "";
+  }
+
+  for (i=0; i<16; i++)
+    sprintf(s+i*2, "%02x", digest[i]);
+
+  s[32]='\0';
+
+  return s;
+}
+
+
+char *MD5::hex_digest(char buffer[33]){
+
+  int i;
+
+  if (!finalized)
+  {
+	 /* cerr << "MD5::hex_digest:  Can't get digest if you haven't "<<
+      "finalized the digest!" <<endl;*/
+    return "";
+  }
+
+  for (i=0; i<16; i++)
+    sprintf(buffer+i*2, "%02x", digest[i]);
+
+  buffer[32]='\0';
+
+  return buffer;
+}
+
+
+// PRIVATE METHODS:
+
+
+
+void MD5::init(){
+  finalized=0;  // we just started!
+
+  // Nothing counted, so count=0
+  count[0] = 0;
+  count[1] = 0;
+
+  // Load magic initialization constants.
+  state[0] = 0x67452301;
+  state[1] = 0xefcdab89;
+  state[2] = 0x98badcfe;
+  state[3] = 0x10325476;
+}
+
+
+
+// Constants for MD5Transform routine.
+// Although we could use C++ style constants, defines are actually better,
+// since they let us easily evade scope clashes.
+
+#define S11 7
+#define S12 12
+#define S13 17
+#define S14 22
+#define S21 5
+#define S22 9
+#define S23 14
+#define S24 20
+#define S31 4
+#define S32 11
+#define S33 16
+#define S34 23
+#define S41 6
+#define S42 10
+#define S43 15
+#define S44 21
+
+
+
+
+// MD5 basic transformation. Transforms state based on block.
+void MD5::transform (uint1 block[64]){
+
+  uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+
+  decode (x, block, 64);
+
+  assert(!finalized);  // not just a user error, since the method is private
+
+  /* Round 1 */
+  FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
+  FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
+  FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
+  FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
+  FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
+  FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
+  FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
+  FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
+  FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
+  FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
+  FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
+  FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
+  FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
+  FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
+  FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
+  FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
+
+ /* Round 2 */
+  GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
+  GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
+  GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
+  GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
+  GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
+  GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
+  GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
+  GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
+  GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
+  GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
+  GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
+  GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
+  GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
+  GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
+  GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
+  GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
+
+  /* Round 3 */
+  HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
+  HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
+  HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
+  HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
+  HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
+  HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
+  HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
+  HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
+  HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
+  HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
+  HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
+  HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
+  HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
+  HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
+  HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
+  HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
+
+  /* Round 4 */
+  II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
+  II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
+  II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
+  II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
+  II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
+  II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
+  II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
+  II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
+  II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
+  II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
+  II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
+  II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
+  II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
+  II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
+  II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
+  II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
+
+  state[0] += a;
+  state[1] += b;
+  state[2] += c;
+  state[3] += d;
+
+  // Zeroize sensitive information.
+  memset ( (uint1 *) x, 0, sizeof(x));
+
+}
+
+
+
+// Encodes input (UINT4) into output (unsigned char). Assumes len is
+// a multiple of 4.
+void MD5::encode (uint1 *output, uint4 *input, uint4 len) {
+
+  unsigned int i, j;
+
+  for (i = 0, j = 0; j < len; i++, j += 4) {
+    output[j]   = (uint1)  (input[i] & 0xff);
+    output[j+1] = (uint1) ((input[i] >> 8) & 0xff);
+    output[j+2] = (uint1) ((input[i] >> 16) & 0xff);
+    output[j+3] = (uint1) ((input[i] >> 24) & 0xff);
+  }
+}
+
+
+
+
+// Decodes input (unsigned char) into output (UINT4). Assumes len is
+// a multiple of 4.
+void MD5::decode (uint4 *output, uint1 *input, uint4 len){
+
+  unsigned int i, j;
+
+  for (i = 0, j = 0; j < len; i++, j += 4)
+    output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
+      (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
+}
+
+
+
+
+
+// Note: Replace "for loop" with standard memcpy if possible.
+void MD5::memcpy (uint1 *output, uint1 *input, uint4 len){
+
+  unsigned int i;
+
+  for (i = 0; i < len; i++)
+    output[i] = input[i];
+}
+
+
+
+// Note: Replace "for loop" with standard memset if possible.
+void MD5::memset (uint1 *output, uint1 value, uint4 len){
+
+  unsigned int i;
+
+  for (i = 0; i < len; i++)
+    output[i] = value;
+}
+
+
+
+// ROTATE_LEFT rotates x left n bits.
+
+inline unsigned int MD5::rotate_left  (uint4 x, uint4 n){
+  return (x << n) | (x >> (32-n))  ;
+}
+
+
+
+
+// F, G, H and I are basic MD5 functions.
+
+inline unsigned int MD5::F            (uint4 x, uint4 y, uint4 z){
+  return (x & y) | (~x & z);
+}
+
+inline unsigned int MD5::G            (uint4 x, uint4 y, uint4 z){
+  return (x & z) | (y & ~z);
+}
+
+inline unsigned int MD5::H            (uint4 x, uint4 y, uint4 z){
+  return x ^ y ^ z;
+}
+
+inline unsigned int MD5::I            (uint4 x, uint4 y, uint4 z){
+  return y ^ (x | ~z);
+}
+
+
+
+// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
+// Rotation is separate from addition to prevent recomputation.
+
+
+inline void MD5::FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
+		    uint4  s, uint4 ac){
+ a += F(b, c, d) + x + ac;
+ a = rotate_left (a, s) +b;
+}
+
+inline void MD5::GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
+		    uint4 s, uint4 ac){
+ a += G(b, c, d) + x + ac;
+ a = rotate_left (a, s) +b;
+}
+
+inline void MD5::HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
+		    uint4 s, uint4 ac){
+ a += H(b, c, d) + x + ac;
+ a = rotate_left (a, s) +b;
+}
+
+inline void MD5::II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
+			     uint4 s, uint4 ac){
+ a += I(b, c, d) + x + ac;
+ a = rotate_left (a, s) +b;
+}
diff --git a/tools/gamedata md5/md5.h b/tools/gamedata md5/md5.h
new file mode 100644
index 00000000..3f6979d9
--- /dev/null
+++ b/tools/gamedata md5/md5.h	
@@ -0,0 +1,106 @@
+// MD5.CC - source code for the C++/object oriented translation and 
+//          modification of MD5.
+
+// Translation and modification (c) 1995 by Mordechai T. Abzug 
+
+// This translation/ modification is provided "as is," without express or 
+// implied warranty of any kind.
+
+// The translator/ modifier does not claim (1) that MD5 will do what you think 
+// it does; (2) that this translation/ modification is accurate; or (3) that 
+// this software is "merchantible."  (Language for this disclaimer partially 
+// copied from the disclaimer below).
+
+/* based on:
+
+   MD5.H - header file for MD5C.C
+   MDDRIVER.C - test driver for MD2, MD4 and MD5
+
+   Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+rights reserved.
+
+License to copy and use this software is granted provided that it
+is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+Algorithm" in all material mentioning or referencing this software
+or this function.
+
+License is also granted to make and use derivative works provided
+that such works are identified as "derived from the RSA Data
+Security, Inc. MD5 Message-Digest Algorithm" in all material
+mentioning or referencing the derived work.
+
+RSA Data Security, Inc. makes no representations concerning either
+the merchantability of this software or the suitability of this
+software for any particular purpose. It is provided "as is"
+without express or implied warranty of any kind.
+
+These notices must be retained in any copies of any part of this
+documentation and/or software.
+
+*/
+
+#include <stdio.h>
+//#include <fstream.h>
+//#include <iostream.h>
+
+class MD5 {
+
+public:
+// methods for controlled operation:
+  MD5              ();  // simple initializer
+  void  update     (unsigned char *input, unsigned int input_length);
+  void  update     (FILE *file);
+  void  finalize   ();
+
+// constructors for special circumstances.  All these constructors finalize
+// the MD5 context.
+  MD5              (unsigned char *string); // digest string, finalize
+  MD5              (FILE *file);            // digest file, close, finalize
+
+// methods to acquire finalized result
+  unsigned char    *raw_digest ();  // digest as a 16-byte binary array
+  unsigned char		*raw_digest(unsigned char buffer[16]);
+  char *            hex_digest ();  // digest as a 33-byte ascii-hex string
+  char *			hex_digest (char buffer[33]); //same as above, passing buffer
+
+
+
+private:
+
+// first, some types:
+  typedef unsigned       int uint4; // assumes integer is 4 words long
+  typedef unsigned short int uint2; // assumes short integer is 2 words long
+  typedef unsigned      char uint1; // assumes char is 1 word long
+
+// next, the private data:
+  uint4 state[4];
+  uint4 count[2];     // number of *bits*, mod 2^64
+  uint1 buffer[64];   // input buffer
+  uint1 digest[16];
+  uint1 finalized;
+
+// last, the private methods, mostly static:
+  void init             ();               // called by all constructors
+  void transform        (uint1 *buffer);  // does the real update work.  Note 
+                                          // that length is implied to be 64.
+
+  static void encode    (uint1 *dest, uint4 *src, uint4 length);
+  static void decode    (uint4 *dest, uint1 *src, uint4 length);
+  static void memcpy    (uint1 *dest, uint1 *src, uint4 length);
+  static void memset    (uint1 *start, uint1 val, uint4 length);
+
+  static inline uint4  rotate_left (uint4 x, uint4 n);
+  static inline uint4  F           (uint4 x, uint4 y, uint4 z);
+  static inline uint4  G           (uint4 x, uint4 y, uint4 z);
+  static inline uint4  H           (uint4 x, uint4 y, uint4 z);
+  static inline uint4  I           (uint4 x, uint4 y, uint4 z);
+  static inline void   FF  (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
+			    uint4 s, uint4 ac);
+  static inline void   GG  (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
+			    uint4 s, uint4 ac);
+  static inline void   HH  (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
+			    uint4 s, uint4 ac);
+  static inline void   II  (uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, 
+			    uint4 s, uint4 ac);
+
+};
diff --git a/tools/gamedata md5/msvc9/gamedatamd5.sln b/tools/gamedata md5/msvc9/gamedatamd5.sln
new file mode 100644
index 00000000..3f787232
--- /dev/null
+++ b/tools/gamedata md5/msvc9/gamedatamd5.sln	
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "gamedatamd5", "gamedatamd5.vcproj", "{E1C96598-E1AC-4928-8930-F8B6CD245B12}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E1C96598-E1AC-4928-8930-F8B6CD245B12}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E1C96598-E1AC-4928-8930-F8B6CD245B12}.Debug|Win32.Build.0 = Debug|Win32
+		{E1C96598-E1AC-4928-8930-F8B6CD245B12}.Release|Win32.ActiveCfg = Release|Win32
+		{E1C96598-E1AC-4928-8930-F8B6CD245B12}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
diff --git a/tools/gamedata md5/msvc9/gamedatamd5.vcproj b/tools/gamedata md5/msvc9/gamedatamd5.vcproj
new file mode 100644
index 00000000..835ebf84
--- /dev/null
+++ b/tools/gamedata md5/msvc9/gamedatamd5.vcproj	
@@ -0,0 +1,219 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9.00"
+	Name="gamedatamd5"
+	ProjectGUID="{E1C96598-E1AC-4928-8930-F8B6CD245B12}"
+	Keyword="Win32Proj"
+	TargetFrameworkVersion="0"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="Debug"
+			IntermediateDirectory="Debug"
+			ConfigurationType="1"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../../../public;../../../public/sourcepawn"
+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="Release"
+			IntermediateDirectory="Release"
+			ConfigurationType="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				AdditionalIncludeDirectories="../../../public;../../../public/sourcepawn"
+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE"
+				RuntimeLibrary="0"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="false"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLinkerTool"
+				LinkIncremental="2"
+				GenerateDebugInformation="true"
+				SubSystem="1"
+				OptimizeReferences="2"
+				EnableCOMDATFolding="2"
+				TargetMachine="1"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCManifestTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCAppVerifierTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath="..\main.h"
+				>
+			</File>
+			<File
+				RelativePath="..\md5.h"
+				>
+			</File>
+			<File
+				RelativePath="..\sm_memtable.h"
+				>
+			</File>
+			<File
+				RelativePath="..\TextParsers.h"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+		</Filter>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath="..\main.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\md5.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\sm_memtable.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\TextParsers.cpp"
+				>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
diff --git a/tools/gamedata md5/sm_memtable.cpp b/tools/gamedata md5/sm_memtable.cpp
new file mode 100644
index 00000000..8f18b136
--- /dev/null
+++ b/tools/gamedata md5/sm_memtable.cpp	
@@ -0,0 +1,112 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#include <string.h>
+#include <malloc.h>
+#include "sm_memtable.h"
+
+BaseMemTable::BaseMemTable(unsigned int init_size)
+{
+	membase = (unsigned char *)malloc(init_size);
+	size = init_size;
+	tail = 0;
+}
+
+BaseMemTable::~BaseMemTable()
+{
+	free(membase);
+	membase = NULL;
+}
+
+int BaseMemTable::CreateMem(unsigned int addsize, void **addr)
+{
+	int idx = (int)tail;
+
+	while (tail + addsize >= size)
+	{
+		size *= 2;
+		membase = (unsigned char *)realloc(membase, size);
+	}
+
+	tail += addsize;
+
+	if (addr)
+	{
+		*addr = (void *)&membase[idx];
+	}
+
+	return idx;
+}
+
+void *BaseMemTable::GetAddress(int index)
+{
+	if (index < 0 || (unsigned int)index >= tail)
+	{
+		return NULL;
+	}
+
+	return &membase[index];
+}
+
+void BaseMemTable::Reset()
+{
+	tail = 0;
+}
+
+BaseStringTable::BaseStringTable(unsigned int init_size) : m_table(init_size)
+{
+}
+
+BaseStringTable::~BaseStringTable()
+{
+}
+
+int BaseStringTable::AddString(const char *string)
+{
+	size_t len = strlen(string) + 1;
+	int idx;
+	char *addr;
+
+	idx = m_table.CreateMem(len, (void **)&addr);
+	strcpy(addr, string);
+
+	return idx;
+}
+
+/*const char *BaseStringTable::GetString(int str)
+{
+	return (const char *)m_table.GetAddress(str);
+}*/
+
+void BaseStringTable::Reset()
+{
+	m_table.Reset();
+}
diff --git a/tools/gamedata md5/sm_memtable.h b/tools/gamedata md5/sm_memtable.h
new file mode 100644
index 00000000..2db4c4e6
--- /dev/null
+++ b/tools/gamedata md5/sm_memtable.h	
@@ -0,0 +1,114 @@
+/**
+ * vim: set ts=4 :
+ * =============================================================================
+ * SourceMod
+ * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
+ * =============================================================================
+ *
+ * This program is free software; you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License, version 3.0, as published by the
+ * Free Software Foundation.
+ * 
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * As a special exception, AlliedModders LLC gives you permission to link the
+ * code of this program (as well as its derivative works) to "Half-Life 2," the
+ * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
+ * by the Valve Corporation.  You must obey the GNU General Public License in
+ * all respects for all other code used.  Additionally, AlliedModders LLC grants
+ * this exception to all derivative works.  AlliedModders LLC defines further
+ * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
+ * or <http://www.sourcemod.net/license.php>.
+ *
+ * Version: $Id$
+ */
+
+#ifndef _INCLUDE_SOURCEMOD_CORE_STRINGTABLE_H_
+#define _INCLUDE_SOURCEMOD_CORE_STRINGTABLE_H_
+
+class BaseMemTable
+{
+public:
+	BaseMemTable(unsigned int init_size);
+	~BaseMemTable();
+public:
+	/**
+	 * Allocates 'size' bytes of memory.
+	 * Optionally outputs the address through 'addr'.
+	 * Returns an index >= 0 on success, < 0 on failure.
+	 */
+	int CreateMem(unsigned int size, void **addr);
+
+	/**
+	 * Given an index into the memory table, returns its address.
+	 * Returns NULL if invalid.
+	 */
+	void *GetAddress(int index);
+
+	/**
+	 * Scraps the memory table.  For caching purposes, the memory 
+	 * is not freed, however subsequent calls to CreateMem() will 
+	 * begin at the first index again.
+	 */
+	void Reset();
+
+	inline unsigned int GetMemUsage()
+	{
+		return size;
+	}
+
+	inline unsigned int GetActualMemUsed()
+	{
+		return tail;
+	}
+
+private:
+	unsigned char *membase;
+	unsigned int size;
+	unsigned int tail;
+};
+
+class BaseStringTable
+{
+public:
+	BaseStringTable(unsigned int init_size);
+	~BaseStringTable();
+public:
+	/** 
+	 * Adds a string to the string table and returns its index.
+	 */
+	int AddString(const char *string);
+
+	/**
+	 * Given an index into the string table, returns the associated string.
+	 */
+	inline const char *GetString(int str)
+	{
+		return (const char *)m_table.GetAddress(str);
+	}
+
+	/**
+	 * Scraps the string table.  For caching purposes, the memory
+	 * is not freed, however subsequent calls to AddString() will 
+	 * begin at the first index again.
+	 */
+	void Reset();
+
+	/**
+	 * Returns the parent BaseMemTable that this string table uses.
+	 */
+	inline BaseMemTable *GetMemTable()
+	{
+		return &m_table;
+	}
+private:
+	BaseMemTable m_table;
+};
+
+#endif //_INCLUDE_SOURCEMOD_CORE_STRINGTABLE_H_