diff --git a/lib/public/tier1.lib b/lib/public/tier1.lib
index 363cb036..5df9a89e 100644
Binary files a/lib/public/tier1.lib and b/lib/public/tier1.lib differ
diff --git a/public/tier0/memalloc.h b/public/tier0/memalloc.h
index ec54c079..ef13940f 100644
--- a/public/tier0/memalloc.h
+++ b/public/tier0/memalloc.h
@@ -14,17 +14,17 @@
 #pragma once
 #endif
 
-// These memory debugging switches aren't relevant under Linux builds since memoverride.cpp
-// isn't built into Linux projects
+#if !defined( NO_MALLOC_OVERRIDE ) && defined( POSIX )
+#define NO_MALLOC_OVERRIDE
+#endif
+
+#if defined( NO_MALLOC_OVERRIDE ) && !defined( NO_HOOK_MALLOC )
+#define NO_HOOK_MALLOC
+#endif
+
 #ifndef POSIX
 // Define this in release to get memory tracking even in release builds
 //#define USE_MEM_DEBUG 1
-
-// Define this in release to get light memory debugging
-//#define USE_LIGHT_MEM_DEBUG
-
-// Define this to require -uselmd to turn light memory debugging on
-//#define LIGHT_MEM_DEBUG_REQUIRES_CMD_LINE_SWITCH
 #endif
 
 #if defined( _MEMTEST )
@@ -57,18 +57,15 @@ typedef size_t (*MemAllocFailHandler_t)( size_t );
 //-----------------------------------------------------------------------------
 abstract_class IMemAlloc
 {
-private:
+public:
 	// Release versions
 	virtual void *Alloc( size_t nSize ) = 0;
-public:
 	virtual void *Realloc( void *pMem, size_t nSize ) = 0;
-
 	virtual void Free( void *pMem ) = 0;
     virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize ) = 0;
 
 	// Debug versions
     virtual void *Alloc( size_t nSize, const char *pFileName, int nLine ) = 0;
-public:
     virtual void *Realloc( void *pMem, size_t nSize, const char *pFileName, int nLine ) = 0;
     virtual void  Free( void *pMem, const char *pFileName, int nLine ) = 0;
     virtual void *Expand_NoLongerSupported( void *pMem, size_t nSize, const char *pFileName, int nLine ) = 0;
@@ -125,8 +122,7 @@ public:
 	virtual void SetStatsExtraInfo( const char *pMapName, const char *pComment ) = 0;
 #endif
 
-	// Returns 0 if no failure, otherwise the size_t of the last requested chunk.
-	//  "I'm sure this is completely thread safe!" Brian Deen 7/19/2012.
+	// Returns 0 if no failure, otherwise the size_t of the last requested chunk
 	virtual size_t MemoryAllocFailed() = 0;
 
 	virtual void CompactIncremental() = 0; 
@@ -156,7 +152,6 @@ inline void *MemAlloc_Alloc( size_t nSize )
 { 
 	return g_pMemAlloc->RegionAlloc( MEMALLOC_REGION, nSize );
 }
-
 inline void *MemAlloc_Alloc( size_t nSize, const char *pFileName, int nLine )
 { 
 	return g_pMemAlloc->RegionAlloc( MEMALLOC_REGION, nSize, pFileName, nLine );
@@ -165,12 +160,11 @@ inline void *MemAlloc_Alloc( size_t nSize, const char *pFileName, int nLine )
 #undef MEMALLOC_REGION
 inline void *MemAlloc_Alloc( size_t nSize )
 { 
-	return g_pMemAlloc->IndirectAlloc( nSize );
+	return g_pMemAlloc->Alloc( nSize );
 }
-
 inline void *MemAlloc_Alloc( size_t nSize, const char *pFileName, int nLine )
 { 
-	return g_pMemAlloc->IndirectAlloc( nSize, pFileName, nLine );
+	return g_pMemAlloc->Alloc( nSize, pFileName, nLine );
 }
 #endif
 inline void MemAlloc_Free( void *ptr )
@@ -181,25 +175,16 @@ inline void MemAlloc_Free( void *ptr, const char *pFileName, int nLine )
 {
 	g_pMemAlloc->Free( ptr, pFileName, nLine );
 }
-
-
-//-----------------------------------------------------------------------------
-
-inline bool ValueIsPowerOfTwo( size_t value )			// don't clash with mathlib definition
-{
-	return (value & ( value - 1 )) == 0;
-}
-
 inline void *MemAlloc_AllocAligned( size_t size, size_t align )
 {
 	unsigned char *pAlloc, *pResult;
 
-	if (!IsPowerOfTwo(align))
+	if (!IsPowerOfTwo(uint(align)))
 		return NULL;
 
 	align = (align > sizeof(void *) ? align : sizeof(void *)) - 1;
 
-	if ( (pAlloc = (unsigned char*)g_pMemAlloc->IndirectAlloc( sizeof(void *) + align + size ) ) == (unsigned char*)NULL)
+	if ( (pAlloc = (unsigned char*)g_pMemAlloc->Alloc( sizeof(void *) + align + size ) ) == (unsigned char*)NULL)
 		return NULL;
 
 	pResult = (unsigned char*)( (size_t)(pAlloc + sizeof(void *) + align ) & ~align );
@@ -212,48 +197,12 @@ inline void *MemAlloc_AllocAligned( size_t size, size_t align, const char *pszFi
 {
 	unsigned char *pAlloc, *pResult;
 
-	if (!IsPowerOfTwo(align))
+	if (!IsPowerOfTwo(uint(align)))
 		return NULL;
 
 	align = (align > sizeof(void *) ? align : sizeof(void *)) - 1;
 
-	if ( (pAlloc = (unsigned char*)g_pMemAlloc->IndirectAlloc( sizeof(void *) + align + size, pszFile, nLine ) ) == (unsigned char*)NULL)
-		return NULL;
-
-	pResult = (unsigned char*)( (size_t)(pAlloc + sizeof(void *) + align ) & ~align );
-	((unsigned char**)(pResult))[-1] = pAlloc;
-
-	return (void *)pResult;
-}
-
-inline void *MemAlloc_AllocAlignedUnattributed( size_t size, size_t align )
-{
-	unsigned char *pAlloc, *pResult;
-
-	if (!ValueIsPowerOfTwo(align))
-		return NULL;
-
-	align = (align > sizeof(void *) ? align : sizeof(void *)) - 1;
-
-	if ( (pAlloc = (unsigned char*)MemAlloc_Alloc( sizeof(void *) + align + size ) ) == (unsigned char*)NULL)
-		return NULL;
-
-	pResult = (unsigned char*)( (size_t)(pAlloc + sizeof(void *) + align ) & ~align );
-	((unsigned char**)(pResult))[-1] = pAlloc;
-
-	return (void *)pResult;
-}
-
-inline void *MemAlloc_AllocAlignedFileLine( size_t size, size_t align, const char *pszFile, int nLine )
-{
-	unsigned char *pAlloc, *pResult;
-
-	if (!ValueIsPowerOfTwo(align))
-		return NULL;
-
-	align = (align > sizeof(void *) ? align : sizeof(void *)) - 1;
-
-	if ( (pAlloc = (unsigned char*)MemAlloc_Alloc( sizeof(void *) + align + size, pszFile, nLine ) ) == (unsigned char*)NULL)
+	if ( (pAlloc = (unsigned char*)g_pMemAlloc->Alloc( sizeof(void *) + align + size, pszFile, nLine ) ) == (unsigned char*)NULL)
 		return NULL;
 
 	pResult = (unsigned char*)( (size_t)(pAlloc + sizeof(void *) + align ) & ~align );
@@ -264,7 +213,7 @@ inline void *MemAlloc_AllocAlignedFileLine( size_t size, size_t align, const cha
 
 inline void *MemAlloc_ReallocAligned( void *ptr, size_t size, size_t align )
 {
-	if ( !ValueIsPowerOfTwo( align ) )
+	if ( !IsPowerOfTwo( uint(align) ) )
 		return NULL;
 
 	// Don't change alignment between allocation + reallocation.
@@ -310,23 +259,6 @@ inline void MemAlloc_FreeAligned( void *pMemBlock )
 	g_pMemAlloc->Free( pAlloc );
 }
 
-inline void MemAlloc_FreeAligned( void *pMemBlock, const char *pszFile, int nLine )
-{
-	void *pAlloc;
-
-	if ( pMemBlock == NULL )
-		return;
-
-	pAlloc = pMemBlock;
-
-	// pAlloc points to the pointer to starting of the memory block
-	pAlloc = (void *)(((size_t)pAlloc & ~( sizeof(void *) - 1 ) ) - sizeof(void *));
-
-	// pAlloc is the pointer to the start of memory block
-	pAlloc = *( (void **)pAlloc );
-	g_pMemAlloc->Free( pAlloc, pszFile, nLine );
-}
-
 inline size_t MemAlloc_GetSizeAligned( void *pMemBlock )
 {
 	void *pAlloc;
@@ -347,37 +279,19 @@ inline size_t MemAlloc_GetSizeAligned( void *pMemBlock )
 //-----------------------------------------------------------------------------
 
 #if (defined(_DEBUG) || defined(USE_MEM_DEBUG))
-
 #define MEM_ALLOC_CREDIT_(tag)	CMemAllocAttributeAlloction memAllocAttributeAlloction( tag, __LINE__ )
 #define MemAlloc_PushAllocDbgInfo( pszFile, line ) g_pMemAlloc->PushAllocDbgInfo( pszFile, line )
 #define MemAlloc_PopAllocDbgInfo() g_pMemAlloc->PopAllocDbgInfo()
 #define MemAlloc_RegisterAllocation( pFileName, nLine, nLogicalSize, nActualSize, nTime ) g_pMemAlloc->RegisterAllocation( pFileName, nLine, nLogicalSize, nActualSize, nTime )
 #define MemAlloc_RegisterDeallocation( pFileName, nLine, nLogicalSize, nActualSize, nTime ) g_pMemAlloc->RegisterDeallocation( pFileName, nLine, nLogicalSize, nActualSize, nTime )
-
 #else
-
 #define MEM_ALLOC_CREDIT_(tag)	((void)0)
 #define MemAlloc_PushAllocDbgInfo( pszFile, line ) ((void)0)
 #define MemAlloc_PopAllocDbgInfo() ((void)0)
 #define MemAlloc_RegisterAllocation( pFileName, nLine, nLogicalSize, nActualSize, nTime ) ((void)0)
 #define MemAlloc_RegisterDeallocation( pFileName, nLine, nLogicalSize, nActualSize, nTime ) ((void)0)
-
 #endif
 
-#define MemAlloc_DumpStats() g_pMemAlloc->DumpStats()
-#define MemAlloc_CompactHeap() g_pMemAlloc->CompactHeap()
-#define MemAlloc_OutOfMemory() g_pMemAlloc->OutOfMemory()
-#define MemAlloc_CompactIncremental() g_pMemAlloc->CompactIncremental()
-#define MemAlloc_DumpStatsFileBase( _filename ) g_pMemAlloc->DumpStatsFileBase( _filename )
-#define MemAlloc_CrtCheckMemory() g_pMemAlloc->CrtCheckMemory()
-#define MemAlloc_GlobalMemoryStatus( _usedMemory, _freeMemory ) g_pMemAlloc->GlobalMemoryStatus( _usedMemory, _freeMemory )
-#define MemAlloc_MemoryAllocFailed() g_pMemAlloc->MemoryAllocFailed()
-
-#define MemAlloc_GetDebugInfoSize() g_pMemAlloc->GetDebugInfoSize()
-#define MemAlloc_SaveDebugInfo( pvDebugInfo ) g_pMemAlloc->SaveDebugInfo( pvDebugInfo )
-#define MemAlloc_RestoreDebugInfo( pvDebugInfo ) g_pMemAlloc->RestoreDebugInfo( pvDebugInfo )
-#define MemAlloc_InitDebugInfo( pvDebugInfo, pchRootFileName, nLine ) g_pMemAlloc->InitDebugInfo( pvDebugInfo, pchRootFileName, nLine )
-#define MemAlloc_GetSize( x ) g_pMemAlloc->GetSize( x );
 //-----------------------------------------------------------------------------
 
 class CMemAllocAttributeAlloction
@@ -398,7 +312,7 @@ public:
 
 //-----------------------------------------------------------------------------
 
-#if defined(MSVC) && ( defined(_DEBUG) || defined(USE_MEM_DEBUG) )
+#if defined(_WIN32) && ( defined(_DEBUG) || defined(USE_MEM_DEBUG) )
 
 	#pragma warning(disable:4290)
 	#pragma warning(push)
@@ -408,14 +322,7 @@ public:
 	// Note: typeid().name() is not threadsafe, so if the project needs to access it in multiple threads
 	// simultaneously, it'll need a mutex.
 	#if defined(_CPPRTTI) && defined(MEM_DEBUG_CLASSNAME)
-
-		template <typename T> const char *MemAllocClassName( T *p )
-		{
-			static const char *pszName = typeid(*p).name(); // @TODO: support having debug heap ignore certain allocations, and ignore memory allocated here [5/7/2009 tom]
-			return pszName;
-		}
-
-		#define MEM_ALLOC_CREDIT_CLASS()	MEM_ALLOC_CREDIT_( MemAllocClassName( this ) )
+		#define MEM_ALLOC_CREDIT_CLASS()	MEM_ALLOC_CREDIT_( typeid(*this).name() )
 		#define MEM_ALLOC_CLASSNAME(type) (typeid((type*)(0)).name())
 	#else
 		#define MEM_ALLOC_CREDIT_CLASS()	MEM_ALLOC_CREDIT_( __FILE__ )
@@ -446,13 +353,8 @@ struct MemAllocFileLine_t
 };
 
 #define MEMALLOC_DEFINE_EXTERNAL_TRACKING( tag ) \
-	static CUtlMap<void *, MemAllocFileLine_t, int> s_##tag##Allocs( DefLessFunc( void *) ); \
-	CUtlMap<void *, MemAllocFileLine_t, int> * g_p##tag##Allocs = &s_##tag##Allocs; \
-	const char * g_psz##tag##Alloc = strcpy( (char *)MemAlloc_Alloc( strlen( #tag "Alloc" ) + 1, "intentional leak", 0 ), #tag "Alloc" );
-
-#define MEMALLOC_DECLARE_EXTERNAL_TRACKING( tag ) \
-	extern CUtlMap<void *, MemAllocFileLine_t, int> * g_p##tag##Allocs; \
-	extern const char * g_psz##tag##Alloc;
+	static CUtlMap<void *, MemAllocFileLine_t, int> g_##tag##Allocs( DefLessFunc( void *) ); \
+	static const char *g_psz##tag##Alloc = strcpy( (char *)g_pMemAlloc->Alloc( strlen( #tag "Alloc" ) + 1, "intentional leak", 0 ), #tag "Alloc" );
 
 #define MemAlloc_RegisterExternalAllocation( tag, p, size ) \
 	if ( !p ) \
@@ -463,7 +365,7 @@ struct MemAllocFileLine_t
 		g_pMemAlloc->GetActualDbgInfo( fileLine.pszFile, fileLine.line ); \
 		if ( fileLine.pszFile != g_psz##tag##Alloc ) \
 		{ \
-			g_p##tag##Allocs->Insert( p, fileLine ); \
+			g_##tag##Allocs.Insert( p, fileLine ); \
 		} \
 		\
 		MemAlloc_RegisterAllocation( fileLine.pszFile, fileLine.line, size, size, 0); \
@@ -475,11 +377,11 @@ struct MemAllocFileLine_t
 	else \
 	{ \
 		MemAllocFileLine_t fileLine = { g_psz##tag##Alloc, 0 }; \
-		CUtlMap<void *, MemAllocFileLine_t, int>::IndexType_t iRecordedFileLine = g_p##tag##Allocs->Find( p ); \
-		if ( iRecordedFileLine !=  g_p##tag##Allocs->InvalidIndex() ) \
+		CUtlMap<void *, MemAllocFileLine_t, int>::IndexType_t iRecordedFileLine = g_##tag##Allocs.Find( p ); \
+		if ( iRecordedFileLine !=  g_##tag##Allocs.InvalidIndex() ) \
 		{ \
-			fileLine = (*g_p##tag##Allocs)[iRecordedFileLine]; \
-			g_p##tag##Allocs->RemoveAt( iRecordedFileLine ); \
+			fileLine = g_##tag##Allocs[iRecordedFileLine]; \
+			g_##tag##Allocs.RemoveAt( iRecordedFileLine ); \
 		} \
 		\
 		MemAlloc_RegisterDeallocation( fileLine.pszFile, fileLine.line, size, size, 0); \
@@ -488,7 +390,6 @@ struct MemAllocFileLine_t
 #else
 
 #define MEMALLOC_DEFINE_EXTERNAL_TRACKING( tag )
-#define MEMALLOC_DECLARE_EXTERNAL_TRACKING( tag )
 #define MemAlloc_RegisterExternalAllocation( tag, p, size ) ((void)0)
 #define MemAlloc_RegisterExternalDeallocation( tag, p, size ) ((void)0)
 
@@ -499,7 +400,7 @@ struct MemAllocFileLine_t
 #elif defined( POSIX )
 
 #if defined( OSX )
-// Mac always aligns allocs, don't need to call posix_memalign
+// Mac always aligns allocs, don't need to call posix_memalign which doesn't exist in 10.5.8 which TF2 still needs to run on
 //inline void *memalign(size_t alignment, size_t size) {void *pTmp=NULL; posix_memalign(&pTmp, alignment, size); return pTmp;}
 inline void *memalign(size_t alignment, size_t size) {void *pTmp=NULL; pTmp = malloc(size); return pTmp;}
 #endif
@@ -535,12 +436,6 @@ inline void *MemAlloc_ReallocAligned( void *ptr, size_t size, size_t align )
 
 	return ptr_new_aligned;
 }
-#else
-#define MemAlloc_GetDebugInfoSize() g_pMemAlloc->GetDebugInfoSize()
-#define MemAlloc_SaveDebugInfo( pvDebugInfo ) g_pMemAlloc->SaveDebugInfo( pvDebugInfo )
-#define MemAlloc_RestoreDebugInfo( pvDebugInfo ) g_pMemAlloc->RestoreDebugInfo( pvDebugInfo )
-#define MemAlloc_InitDebugInfo( pvDebugInfo, pchRootFileName, nLine ) g_pMemAlloc->InitDebugInfo( pvDebugInfo, pchRootFileName, nLine )
-
 #endif // !STEAM && !NO_MALLOC_OVERRIDE
 
 //-----------------------------------------------------------------------------
@@ -555,122 +450,9 @@ inline void *MemAlloc_ReallocAligned( void *ptr, size_t size, size_t align )
 
 #define MemAlloc_PushAllocDbgInfo( pszFile, line )
 #define MemAlloc_PopAllocDbgInfo()
-#define MemAlloc_RegisterAllocation( pFileName, nLine, nLogicalSize, nActualSize, nTime ) ((void)0)
-#define MemAlloc_RegisterDeallocation( pFileName, nLine, nLogicalSize, nActualSize, nTime ) ((void)0)
-#define MemAlloc_DumpStats() ((void)0)
-#define MemAlloc_CompactHeap() ((void)0)
-#define MemAlloc_OutOfMemory() ((void)0)
-#define MemAlloc_CompactIncremental() ((void)0)
-#define MemAlloc_DumpStatsFileBase( _filename ) ((void)0)
-inline bool MemAlloc_CrtCheckMemory() { return true; }
-inline void MemAlloc_GlobalMemoryStatus( size_t *pusedMemory, size_t *pfreeMemory )
-{
-	*pusedMemory = 0;
-	*pfreeMemory = 0;
-}
-#define MemAlloc_MemoryAllocFailed() 0
-
-#define MemAlloc_GetDebugInfoSize() 0
-#define MemAlloc_SaveDebugInfo( pvDebugInfo ) ((void)0)
-#define MemAlloc_RestoreDebugInfo( pvDebugInfo ) ((void)0)
-#define MemAlloc_InitDebugInfo( pvDebugInfo, pchRootFileName, nLine ) ((void)0)
-
-
 #define MEMALLOC_DEFINE_EXTERNAL_TRACKING( tag )
-#define MemAlloc_RegisterExternalAllocation( tag, p, size ) ((void)0)
-#define MemAlloc_RegisterExternalDeallocation( tag, p, size ) ((void)0)
-
 #endif // !STEAM && NO_MALLOC_OVERRIDE
 
 //-----------------------------------------------------------------------------
 
-
-
-// linux memory tracking via hooks.
-#if defined( POSIX ) && !defined( NO_HOOK_MALLOC )
-
-PLATFORM_INTERFACE void MemoryLogMessage( char const *s );						// throw a message into the memory log
-PLATFORM_INTERFACE void EnableMemoryLogging( bool bOnOff );
-PLATFORM_INTERFACE void DumpMemoryLog( int nThresh );
-PLATFORM_INTERFACE void DumpMemorySummary( void );
-PLATFORM_INTERFACE void SetMemoryMark( void );
-PLATFORM_INTERFACE void DumpChangedMemory( int nThresh );
-
-#else
-
-FORCEINLINE void MemoryLogMessage( char const *s )
-{
-}
-
-FORCEINLINE void EnableMemoryLogging( bool bOnOff )
-{
-}
-FORCEINLINE void DumpMemoryLog( int nThresh )
-{
-}
-FORCEINLINE void DumpMemorySummary( void )
-{
-}
-FORCEINLINE void SetMemoryMark( void )
-{
-}
-FORCEINLINE void DumpChangedMemory( int nThresh )
-{
-}
-
-#endif
-
-#ifdef POSIX
-// ApproximateProcessMemoryUsage returns the approximate memory footprint of this process.
-PLATFORM_INTERFACE size_t ApproximateProcessMemoryUsage( void );
-#else
-FORCEINLINE size_t ApproximateProcessMemoryUsage( void )
-{
-	return 0;
-}
-#endif
-
-struct aligned_tmp_t
-{
-	// empty base class
-};
-
-// template here to allow adding alignment at levels of hierarchy that aren't the base
-template< int bytesAlignment = 16, class T = aligned_tmp_t >
-class CAlignedNewDelete : public T
-{
-public:
-	/*
-	Note that this class does not overload operator new[] and delete[] which means that
-	classes that depend on this for alignment may end up misaligned if an array is
-	allocated. This problem is now mostly theoretical because this class is mostly
-	obsolete.
-	*/
-	void *operator new( size_t nSize )
-	{
-		return MemAlloc_AllocAligned( nSize, bytesAlignment );
-	}
-
-	void* operator new( size_t nSize, int nBlockUse, const char *pFileName, int nLine )
-	{
-		return MemAlloc_AllocAlignedFileLine( nSize, bytesAlignment, pFileName, nLine );
-	}
-
-	void operator delete(void *pData)
-	{
-		if ( pData )
-		{
-			MemAlloc_FreeAligned( pData );
-		}
-	}
-
-	void operator delete( void* pData, int nBlockUse, const char *pFileName, int nLine )
-	{
-		if ( pData )
-		{
-			MemAlloc_FreeAligned( pData, pFileName, nLine );
-		}
-	}
-};
-
 #endif /* TIER0_MEMALLOC_H */
diff --git a/public/tier0/memdbgon.h b/public/tier0/memdbgon.h
index 13b4ed42..b361d456 100644
--- a/public/tier0/memdbgon.h
+++ b/public/tier0/memdbgon.h
@@ -11,6 +11,14 @@
 // to include this potentially multiple times (since we can deactivate debugging
 // by including memdbgoff.h)
 
+#if !defined( NO_MALLOC_OVERRIDE ) && defined( POSIX )
+#define NO_MALLOC_OVERRIDE
+#endif
+
+#if defined( NO_MALLOC_OVERRIDE ) && !defined( NO_HOOK_MALLOC )
+#define NO_HOOK_MALLOC
+#endif
+
 #if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE)
 
 // SPECIAL NOTE #2: This must be the final include in a .cpp or .h file!!!
@@ -19,53 +27,47 @@
 #define USE_MEM_DEBUG 1
 #endif
 
-#if defined(NO_HOOK_MALLOC)
-#undef USE_MEM_DEBUG
-#endif
-
 // If debug build or ndebug and not already included MS custom alloc files, or already included this file
 #if (defined(_DEBUG) || !defined(_INC_CRTDBG)) || defined(MEMDBGON_H)
 
-#include "tier0/basetypes.h"
-
-#include "tier0/valve_off.h"
-	#ifdef COMPILER_MSVC
-		#include <tchar.h>
-	#else
-		#include <wchar.h>
-	#endif
-	#include <string.h>
-	#include <stdlib.h>
-#include "tier0/valve_on.h"
-
+#include "basetypes.h"
+#ifdef _WIN32
+#include <tchar.h>
+#else
+#include <wchar.h>
+#endif
+#include <string.h>
+#if defined __APPLE__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif
 #include "commonmacros.h"
 #include "memalloc.h"
 
-#ifdef _WIN32
-#ifndef MEMALLOC_REGION
-#define MEMALLOC_REGION 0
-#endif
-#else
-#undef MEMALLOC_REGION
-#endif
-
 #if defined(USE_MEM_DEBUG)
-	#if defined(POSIX)
+	#if defined(_LINUX) || defined(__APPLE__)
+	
 		#define _NORMAL_BLOCK 1
 		
-		#include "tier0/valve_off.h"
 		#include <cstddef>
 		#include <glob.h>
 		#include <new>
 		#include <sys/types.h>
+		
 		#if !defined( DID_THE_OPERATOR_NEW )
-                        #define DID_THE_OPERATOR_NEW
-			// posix doesn't have a new of this form, so we impl our own
-			void* operator new( size_t nSize, int blah, const char *pFileName, int nLine );
-			void* operator new[]( size_t nSize, int blah, const char *pFileName, int nLine );
+			#define DID_THE_OPERATOR_NEW
+			inline void* operator new( size_t nSize, int blah, const char *pFileName, int nLine )
+			{
+				return g_pMemAlloc->Alloc( nSize, pFileName, nLine );
+			}
+			inline void* operator new[]( size_t nSize, int blah, const char *pFileName, int nLine )
+			{
+				return g_pMemAlloc->Alloc( nSize, pFileName, nLine );
+			}
 		#endif
 	
-	#else // defined(POSIX)
+	#else // defined(_LINUX)
 	
 		// Include crtdbg.h and make sure _DEBUG is set to 1.
 		#if !defined(_DEBUG)
@@ -76,7 +78,7 @@
 			#include <crtdbg.h>
 		#endif // !defined(_DEBUG)
 	
-	#endif // defined(POSIX)
+	#endif // defined(_LINUX)
 #endif
 
 #include "tier0/memdbgoff.h"
@@ -103,30 +105,22 @@ inline void *MemAlloc_InlineCallocMemset( void *pMem, size_t nCount, size_t nEle
 }
 #endif
 
-
 #define calloc(c, s)		MemAlloc_InlineCallocMemset(malloc(c*s), c, s)
-#ifndef USE_LIGHT_MEM_DEBUG
 #define free(p)				g_pMemAlloc->Free( p )
-#define _aligned_free( p )	MemAlloc_FreeAligned( p )
-#else
-extern const char *g_pszModule; 
-#define free(p)				g_pMemAlloc->Free( p, g_pszModule, 0 )
-#define _aligned_free( p )	MemAlloc_FreeAligned( p, g_pszModule, 0 )
-#endif
 #define _msize(p)			g_pMemAlloc->GetSize( p )
 #define _expand(p, s)		_expand_NoLongerSupported(p, s)
+#define _aligned_free( p )	MemAlloc_FreeAligned( p )
 
 // --------------------------------------------------------
 // Debug path
 #if defined(USE_MEM_DEBUG)
 
-#define malloc(s)				MemAlloc_Alloc( s, __FILE__, __LINE__)
+#define malloc(s)				g_pMemAlloc->Alloc( s, __FILE__, __LINE__)
 #define realloc(p, s)			g_pMemAlloc->Realloc( p, s, __FILE__, __LINE__ )
-#define _aligned_malloc( s, a )	MemAlloc_AllocAlignedFileLine( s, a, __FILE__, __LINE__ )
+#define _aligned_malloc( s, a )	MemAlloc_AllocAligned( s, a, __FILE__, __LINE__ )
 
 #define _malloc_dbg(s, t, f, l)	WHYCALLINGTHISDIRECTLY(s)
 
-#if !defined( GNUC )
 #if defined(__AFX_H__) && defined(DEBUG_NEW)
 	#define new DEBUG_NEW
 #else
@@ -134,7 +128,6 @@ extern const char *g_pszModule;
 	#define MEMALL_DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
 	#define new MEMALL_DEBUG_NEW
 #endif
-#endif
 
 #undef _strdup
 #undef strdup
@@ -157,7 +150,7 @@ inline char *MemAlloc_StrDup(const char *pString, const char *pFileName, unsigne
 		return NULL;
 	
 	size_t len = strlen(pString) + 1;
-	if ((pMemory = (char *)MemAlloc_Alloc(len, pFileName, nLine)) != NULL)
+	if ((pMemory = (char *)g_pMemAlloc->Alloc(len, pFileName, nLine)) != NULL)
 	{
 		return strcpy( pMemory, pString );
 	}
@@ -173,7 +166,7 @@ inline wchar_t *MemAlloc_WcStrDup(const wchar_t *pString, const char *pFileName,
 		return NULL;
 	
 	size_t len = (wcslen(pString) + 1);
-	if ((pMemory = (wchar_t *)MemAlloc_Alloc(len * sizeof(wchar_t), pFileName, nLine)) != NULL)
+	if ((pMemory = (wchar_t *)g_pMemAlloc->Alloc(len * sizeof(wchar_t), pFileName, nLine)) != NULL)
 	{
 		return wcscpy( pMemory, pString );
 	}
@@ -187,15 +180,9 @@ inline wchar_t *MemAlloc_WcStrDup(const wchar_t *pString, const char *pFileName,
 // --------------------------------------------------------
 // Release path
 
-#ifndef USE_LIGHT_MEM_DEBUG
-#define malloc(s)				MemAlloc_Alloc( s )
+#define malloc(s)				g_pMemAlloc->Alloc( s )
 #define realloc(p, s)			g_pMemAlloc->Realloc( p, s )
 #define _aligned_malloc( s, a )	MemAlloc_AllocAligned( s, a )
-#else
-#define malloc(s)				MemAlloc_Alloc( s, g_pszModule, 0  )
-#define realloc(p, s)			g_pMemAlloc->Realloc( p, s, g_pszModule, 0 )
-#define _aligned_malloc( s, a )	MemAlloc_AllocAlignedFileLine( s, a, g_pszModule, 0 )
-#endif
 
 #ifndef _malloc_dbg
 #define _malloc_dbg(s, t, f, l)	WHYCALLINGTHISDIRECTLY(s)
@@ -224,7 +211,7 @@ inline char *MemAlloc_StrDup(const char *pString)
 		return NULL;
 
 	size_t len = strlen(pString) + 1;
-	if ((pMemory = (char *)malloc(len)) != NULL)
+	if ((pMemory = (char *)g_pMemAlloc->Alloc(len)) != NULL)
 	{
 		return strcpy( pMemory, pString );
 	}
@@ -240,7 +227,7 @@ inline wchar_t *MemAlloc_WcStrDup(const wchar_t *pString)
 		return NULL;
 
 	size_t len = (wcslen(pString) + 1);
-	if ((pMemory = (wchar_t *)malloc(len * sizeof(wchar_t))) != NULL)
+	if ((pMemory = (wchar_t *)g_pMemAlloc->Alloc(len * sizeof(wchar_t))) != NULL)
 	{
 		return wcscpy( pMemory, pString );
 	}
@@ -265,9 +252,4 @@ inline wchar_t *MemAlloc_WcStrDup(const wchar_t *pString)
 #endif
 #endif // _INC_CRTDBG
 
-#else
-
-// Needed for MEM_ALLOC_CREDIT(), MemAlloc_Alloc(), etc.
-#include "memalloc.h"
-
 #endif // !STEAM && !NO_MALLOC_OVERRIDE
diff --git a/tier1/KeyValues.cpp b/tier1/KeyValues.cpp
index 18b1c220..7217799d 100644
--- a/tier1/KeyValues.cpp
+++ b/tier1/KeyValues.cpp
@@ -27,6 +27,17 @@
 // memdbgon must be the last include file in a .cpp file!!!
 #include <tier0/memdbgon.h>
 
+template<typename T>
+T *KVStringAlloc(size_t nLength)
+{
+	return reinterpret_cast<T*>(MemAlloc_Alloc(sizeof(T) * nLength));
+}
+
+void KVStringDelete(void* pMem)
+{
+	MemAlloc_Free(pMem);
+}
+
 static const char * s_LastFileLoadingFrom = "unknown"; // just needed for error messages
 
 #define KEYVALUES_TOKEN_SIZE	1024
@@ -323,9 +334,9 @@ void KeyValues::RemoveEverything()
 		delete dat;
 	}
 
-	delete [] m_sValue;
+	KVStringDelete(m_sValue);
 	m_sValue = NULL;
-	delete [] m_wsValue;
+	KVStringDelete(m_wsValue);
 	m_wsValue = NULL;
 }
 
@@ -1280,9 +1291,9 @@ void KeyValues::SetColor( const char *keyName, Color value)
 void KeyValues::SetStringValue( char const *strValue )
 {
 	// delete the old value
-	delete [] m_sValue;
+	KVStringDelete(m_sValue);
 	// make sure we're not storing the WSTRING  - as we're converting over to STRING
-	delete [] m_wsValue;
+	KVStringDelete(m_wsValue);
 	m_wsValue = NULL;
 
 	if (!strValue)
@@ -1293,7 +1304,7 @@ void KeyValues::SetStringValue( char const *strValue )
 
 	// allocate memory for the new value and copy it in
 	int len = Q_strlen( strValue );
-	m_sValue = new char[len + 1];
+	m_sValue = KVStringAlloc<char>(len + 1);
 	Q_memcpy( m_sValue, strValue, len+1 );
 
 	m_iDataType = TYPE_STRING;
@@ -1309,9 +1320,9 @@ void KeyValues::SetString( const char *keyName, const char *value )
 	if ( dat )
 	{
 		// delete the old value
-		delete [] dat->m_sValue;
+		KVStringDelete(dat->m_sValue);
 		// make sure we're not storing the WSTRING  - as we're converting over to STRING
-		delete [] dat->m_wsValue;
+		KVStringDelete(dat->m_wsValue);
 		dat->m_wsValue = NULL;
 
 		if (!value)
@@ -1322,7 +1333,7 @@ void KeyValues::SetString( const char *keyName, const char *value )
 
 		// allocate memory for the new value and copy it in
 		int len = Q_strlen( value );
-		dat->m_sValue = new char[len + 1];
+		dat->m_sValue = KVStringAlloc<char>(len + 1);
 		Q_memcpy( dat->m_sValue, value, len+1 );
 
 		dat->m_iDataType = TYPE_STRING;
@@ -1338,9 +1349,9 @@ void KeyValues::SetWString( const char *keyName, const wchar_t *value )
 	if ( dat )
 	{
 		// delete the old value
-		delete [] dat->m_wsValue;
+		KVStringDelete(dat->m_wsValue);
 		// make sure we're not storing the STRING  - as we're converting over to WSTRING
-		delete [] dat->m_sValue;
+		KVStringDelete(dat->m_sValue);
 		dat->m_sValue = NULL;
 
 		if (!value)
@@ -1351,7 +1362,7 @@ void KeyValues::SetWString( const char *keyName, const wchar_t *value )
 
 		// allocate memory for the new value and copy it in
 		int len = wcslen( value );
-		dat->m_wsValue = new wchar_t[len + 1];
+		dat->m_wsValue = KVStringAlloc<wchar_t>(len + 1);
 		Q_memcpy( dat->m_wsValue, value, (len+1) * sizeof(wchar_t) );
 
 		dat->m_iDataType = TYPE_WSTRING;
@@ -1382,12 +1393,12 @@ void KeyValues::SetUint64( const char *keyName, uint64 value )
 	if ( dat )
 	{
 		// delete the old value
-		delete [] dat->m_sValue;
+		KVStringDelete(dat->m_sValue);
 		// make sure we're not storing the WSTRING  - as we're converting over to STRING
-		delete [] dat->m_wsValue;
+		KVStringDelete(dat->m_wsValue);
 		dat->m_wsValue = NULL;
 
-		dat->m_sValue = new char[sizeof(uint64)];
+		dat->m_sValue = KVStringAlloc<char>(sizeof(uint64));
 		*((uint64 *)dat->m_sValue) = value;
 		dat->m_iDataType = TYPE_UINT64;
 	}
@@ -1444,7 +1455,7 @@ void KeyValues::RecursiveCopyKeyValues( KeyValues& src )
 			if( src.m_sValue )
 			{
 				int len = Q_strlen(src.m_sValue) + 1;
-				m_sValue = new char[len];
+				m_sValue = KVStringAlloc<char>(len);
 				Q_strncpy( m_sValue, src.m_sValue, len );
 			}
 			break;
@@ -1453,7 +1464,7 @@ void KeyValues::RecursiveCopyKeyValues( KeyValues& src )
 				m_iValue = src.m_iValue;
 				Q_snprintf( buf,sizeof(buf), "%d", m_iValue );
 				int len = Q_strlen(buf) + 1;
-				m_sValue = new char[len];
+				m_sValue = KVStringAlloc<char>(len);
 				Q_strncpy( m_sValue, buf, len  );
 			}
 			break;
@@ -1462,7 +1473,7 @@ void KeyValues::RecursiveCopyKeyValues( KeyValues& src )
 				m_flValue = src.m_flValue;
 				Q_snprintf( buf,sizeof(buf), "%f", m_flValue );
 				int len = Q_strlen(buf) + 1;
-				m_sValue = new char[len];
+				m_sValue = KVStringAlloc<char>(len);
 				Q_strncpy( m_sValue, buf, len );
 			}
 			break;
@@ -1473,7 +1484,7 @@ void KeyValues::RecursiveCopyKeyValues( KeyValues& src )
 			break;
 		case TYPE_UINT64:
 			{
-				m_sValue = new char[sizeof(uint64)];
+				m_sValue = KVStringAlloc<char>(sizeof(uint64));
 				Q_memcpy( m_sValue, src.m_sValue, sizeof(uint64) );
 			}
 			break;
@@ -1584,7 +1595,7 @@ KeyValues *KeyValues::MakeCopy( void ) const
 			{
 				int len = Q_strlen( m_sValue );
 				Assert( !newKeyValue->m_sValue );
-				newKeyValue->m_sValue = new char[len + 1];
+				newKeyValue->m_sValue = KVStringAlloc<char>(len + 1);
 				Q_memcpy( newKeyValue->m_sValue, m_sValue, len+1 );
 			}
 		}
@@ -1594,7 +1605,7 @@ KeyValues *KeyValues::MakeCopy( void ) const
 			if ( m_wsValue )
 			{
 				int len = wcslen( m_wsValue );
-				newKeyValue->m_wsValue = new wchar_t[len+1];
+				newKeyValue->m_wsValue = KVStringAlloc<wchar_t>(len + 1);
 				Q_memcpy( newKeyValue->m_wsValue, m_wsValue, (len+1)*sizeof(wchar_t));
 			}
 		}
@@ -1620,7 +1631,7 @@ KeyValues *KeyValues::MakeCopy( void ) const
 		break;
 
 	case TYPE_UINT64:
-		newKeyValue->m_sValue = new char[sizeof(uint64)];
+		newKeyValue->m_sValue = KVStringAlloc<char>(sizeof(uint64));
 		Q_memcpy( newKeyValue->m_sValue, m_sValue, sizeof(uint64) );
 		break;
 	};
@@ -2062,7 +2073,7 @@ void KeyValues::RecursiveLoadFromBuffer( char const *resourceName, CUtlBuffer &b
 			
 			if (dat->m_sValue)
 			{
-				delete[] dat->m_sValue;
+				KVStringDelete(dat->m_sValue);
 				dat->m_sValue = NULL;
 			}
 
@@ -2094,7 +2105,7 @@ void KeyValues::RecursiveLoadFromBuffer( char const *resourceName, CUtlBuffer &b
 							digit -= 'A' - ( '9' + 1 );
 					retVal = ( retVal * 16 ) + ( digit - '0' );
 				}
-				dat->m_sValue = new char[sizeof(uint64)];
+				dat->m_sValue = KVStringAlloc<char>(sizeof(uint64));
 				*((uint64 *)dat->m_sValue) = retVal;
 				dat->m_iDataType = TYPE_UINT64;
 			}
@@ -2116,7 +2127,7 @@ void KeyValues::RecursiveLoadFromBuffer( char const *resourceName, CUtlBuffer &b
 			if (dat->m_iDataType == TYPE_STRING)
 			{
 				// copy in the string information
-				dat->m_sValue = new char[len+1];
+				dat->m_sValue = KVStringAlloc<char>(len + 1);
 				Q_memcpy( dat->m_sValue, value, len+1 );
 			}
 
@@ -2274,7 +2285,7 @@ bool KeyValues::ReadAsBinary( CUtlBuffer &buffer )
 				token[KEYVALUES_TOKEN_SIZE-1] = 0;
 
 				int len = Q_strlen( token );
-				dat->m_sValue = new char[len + 1];
+				dat->m_sValue = KVStringAlloc<char>(len + 1);
 				Q_memcpy( dat->m_sValue, token, len+1 );
 								
 				break;
@@ -2293,7 +2304,7 @@ bool KeyValues::ReadAsBinary( CUtlBuffer &buffer )
 
 		case TYPE_UINT64:
 			{
-				dat->m_sValue = new char[sizeof(uint64)];
+				dat->m_sValue = KVStringAlloc<char>(sizeof(uint64));
 				*((double *)dat->m_sValue) = buffer.GetDouble();
 			}