#ifndef mempool___mempool_h
#define mempool___mempool_h


/*
 * This is where you may alter options to give mempool++
 */

//#define MEMPOOL_DEBUGGING					 //Causes mempool++ to spit out what it's doing to the console
//#define MEMPOOL_ASSERTS						 //Causes mempool++ to check what it's doing and look for impossible cases
#define MEMPOOL_OVERFLOW 3.0f / 4.0f		 //Changes how full a pool is before going to fallbacks
//#define MEMPOOL_DETERMINE_DISTRIBUTION		 //Allows mempool++ to automatically give you the best distribution
#define MEMPOOL_DETERMINE_SCALAR 5.0f / 3.0f //Gives you this times the max number at any given time from distribution
#define MEMPOOL_FALLBACK_DEPTH 3
//#define MEMPOOL_PERFORMANCE_DEBUGGING
//#define private public


//version info
#define __MEMPOOL_MAJOR__ 1
#define __MEMPOOL_MINOR__ 2
#define __MEMPOOL_PATCH__ 0
#define __MEMPOOL_VERSION__ (__MEMPOOL_MAJOR__ * 10000 + __MEMPOOL_MINOR__ * 100 + __MEMPOOL_PATCH__)

/*
 * This is where special function / macro for special options are
 */

#ifdef MEMPOOL_DEBUGGING
	#include <iostream>
	#define MEMPOOL_DEBUG(x) std::cout << x << std::endl;
#else
	#define MEMPOOL_DEBUG(x)
#endif

#ifdef MEMPOOL_ASSERTS
	#include <iostream>
	#define MEMPOOL_ASSERT(condition) if (pool_unlikely(!(condition))){ std::cout << #condition << " isn't true" << std::endl; }
	#define MEMPOOL_ASSERT2(condition, out) if (pool_unlikely(!(condition))){ std::cout << out << std::endl; }
#else
	#define MEMPOOL_ASSERT(condition)
	#define MEMPOOL_ASSERT2(condition, out)
#endif

#ifdef MEMPOOL_PERFORMANCE_DEBUGGING
	#include <iostream>
	#include <sstream>
	#include <string>
	#define MEMPOOL_PERFORMANCE_DEBUG(x) std::cout << x << std::endl;
#else
	#define MEMPOOL_PERFORMANCE_DEBUG(x)
#endif



/*
 * This is where compiler-specific code goes
 */
#ifdef __GNUC__
    #if (__GNUC__ >= 3)
	   #define POOL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
    #else
	   #define POOL_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100)
    #endif

    #if (POOL_GCC_VERSION >= 40300)
	   #define pool_hot pool_nothrow __attribute__ ((hot))
	#else
		#define pool_hot pool_nothrow
	#endif
	
	#if (POOL_GCC_VERSION >= 29600)
		#define pool_likely(x) __builtin_expect((long)((bool)(x)),1)
		#define pool_unlikely(x) __builtin_expect((long)((bool)(x)),0)
	#else
		#define pool_likely(x) x
		#define pool_unlikely(x) x
	#endif
	
	#define pool_nothrow throw()
#else
	#define pool_hot pool_nothrow
	#define pool_likely(x) x
	#define pool_unlikely(x) x
	#define pool_nothrow
#endif

#include <cstring>

/*
 *	This is where the classes are
 */

//Callbacks for fallback if the pool is out of space
class mempool_callbacks {
public:
	typedef void * (*mallocer_t)(size_t);
	typedef void(*freer_t)(void *);
	typedef void * (*reallocer_t)(void *, size_t);

	//Allows the user to alter where the fallbacks point to
	static inline void set(mallocer_t mallocer, reallocer_t reallocer, freer_t freer) pool_nothrow {
		get_instance()._malloc = mallocer;
		get_instance()._free = freer;
		get_instance()._realloc = reallocer;
	}
	
	//allocates memory
	static inline void * allocate(size_t size) pool_nothrow { 
		MEMPOOL_DEBUG("Returing malloced memory:" << size << " bytes");
		return get_instance()._malloc(size); 
	}
	
	//frees memory
	static inline void deallocate(void * ptr) pool_nothrow { 
		MEMPOOL_DEBUG("Freeing malloced memory: " << ptr);
		get_instance()._free(ptr);
	}
	
	static inline void * reallocate(void * ptr, size_t size) pool_nothrow {
		MEMPOOL_DEBUG("Reallocating memory: " << ptr << " to " << size << " bytes");
		return get_instance()._realloc(ptr, size);
	}
private:
	//Retrieves a Meyers singleton
	static inline mempool_callbacks & get_instance(void) pool_nothrow {
		static mempool_callbacks _single(std::malloc, std::realloc, std::free);
		return _single;
	}
				
	//The constructor
	inline mempool_callbacks(mallocer_t mallocer, reallocer_t reallocer, freer_t freer) :
		_malloc(mallocer),
		_free(freer),
		_realloc(reallocer){
	}
	
	//not copyable
	mempool_callbacks & operator = (const mempool_callbacks & other);
	mempool_callbacks(const mempool_callbacks & other);
	
	//member callbacks
	mallocer_t _malloc;
	reallocer_t _realloc;
	freer_t _free;
};

//The workhorse of the templates library, a class that holds a pool that it allocates memory from
template <typename T, size_t size>
class object_memory_pool;  //forward declaration

template <size_t bytes, size_t size>
class memory_pool_no_fullflag {  //forward declaration
public:
	memory_pool_no_fullflag<bytes, size>():
	_link(NULL),
	current(0),
	depth(0),
	threshold((size_t)((float)size * (MEMPOOL_OVERFLOW))),
	memoryPool_end(memoryPool_start + (size * bytes)),
	used_end(used_start + size),
	runningPointer(used_start)
	{
		std::memset(used_start, 0, size * sizeof(bool));
	}
	
	virtual ~memory_pool_no_fullflag(void){
		if (_link){
			_link -> ~memory_pool_no_fullflag();
			mempool_callbacks::deallocate(_link);
		}
	}
	
	inline size_t load(void) const pool_nothrow {
		return current;
	}
	
	inline void * allocate(void) pool_hot {
		if (void * res = allocate_nofallback()){
			return res;
		}
		return _link_allocate();
	}
	
	inline void deallocate(void * ptr) pool_hot {
		if (memory_pool_no_fullflag<bytes, size> * container = contains(ptr)){
			container -> deallocate_nofallback(ptr);
		} else {
			mempool_callbacks::deallocate(ptr);
		}
	}
	
	void * allocate_nofallback() pool_hot {
		if (!(*runningPointer)) return _return_current();
		if (++runningPointer >= used_end) runningPointer = used_start;
		if (current < threshold){
			//make sure it doesnt loop around infinity so point it to itself
			const bool * position = runningPointer; 
			do {
				if (!(*runningPointer)) return _return_current();
				if (++runningPointer >= used_end) runningPointer = used_start;
			} while (position != runningPointer);
			MEMPOOL_ASSERT2(false, "Got to impossible code location");
		}
	
		MEMPOOL_DEBUG("Returing null");
		return NULL;
	}
	
	void deallocate_nofallback(void * ptr) pool_hot {
		MEMPOOL_ASSERT2(current, "current not positive");
		--current;
		MEMPOOL_DEBUG("Freeing slot " << ((char*)ptr - memoryPool_start) / bytes);
		MEMPOOL_DEBUG("  pointer=" << ptr);
		MEMPOOL_ASSERT2((((char*)ptr - memoryPool_start) / bytes) < size, "Freeing slot " << (((char*)ptr - memoryPool_start) / bytes) << " in a pool with only " << size << " items");
		MEMPOOL_ASSERT2(used_start[((char*)ptr - memoryPool_start) / bytes], "Freeing " << ptr << " and it's already been freed");
		used_start[(((char*)ptr - memoryPool_start) / bytes)] = false;
	}
	
	inline memory_pool_no_fullflag<bytes, size> * contains(void * ptr) pool_hot {
		if ((ptr >= memoryPool_start) && (ptr < memoryPool_end)) return this;
		return (_link) ? _link -> contains(ptr) : NULL;
	}
	
	#ifdef MEMPOOL_PERFORMANCE_DEBUGGING
		const char * const getName(void){ return "memory_pool_no_fullflag"; }
		
		const char * getDepth(){
			static const char * depths[15] = {
				" ",
				"  ",
				"   ",
				"    ",
				"     ",
				"      ",
				"       ",
				"        ",
				"         ",
				"          ",
				"           ",
				"            ",
				"             ",
				"              ",
				"-              ",
			};
			if (depth > 14) return depths[14];
			return depths[depth];
		}
		
		std::string dump(void){
			std::stringstream output;
			output << getDepth() << getName() << "<" << bytes << ", " << size << ">: " << (void*)this << std::endl;
			output << getDepth() << "Currently holding: " << current << " items." << std::endl;
			//_____
			output << getDepth() << "+";
			for(int i = 0; i < 78; ++i){
				output << "_";
			}
			output << "+" << std::endl << getDepth() << "|";
			
			//Fill in
			int i;
			for(i = 0; i < size; ++i){
				if ((i % 80 == 0) && (i != 0)){
					output << "|" << std::endl << getDepth() << "|";
				}
				if (i == (runningPointer - used_start)){
					if (used_start[i]){
						output << "R";
					} else {
						output << "P";
					}
				} else if (used_start[i]){
					output << "X";
				} else {
					output << " ";
				}
			}
			
			for(; (i % 80) != 0; ++i){
				output << "+";
			}
			
			//-------
			output << getDepth() << "+";
			for(i = 0; i < 78; ++i){
				output << "-";
			}
			output << "+";
			if (_link){
				output << "----+" << std::endl;
			}
			return output.str();
		}
	#endif
protected:
	//copy ctors and assignment operator
	memory_pool_no_fullflag & operator = (const memory_pool_no_fullflag & other);
	memory_pool_no_fullflag(const memory_pool_no_fullflag & other);
	
	inline void * _return_current(void) pool_hot {
		*runningPointer = true;
		++current;
		MEMPOOL_DEBUG("Returning slot " << runningPointer - used_start << " at depth " << depth);
		MEMPOOL_DEBUG("  memoryPool_start=" << (void*)memoryPool_start);
		MEMPOOL_DEBUG("  memoryPool_end  =" << (void*)memoryPool_end);
		MEMPOOL_DEBUG("  return value    =" << (void*)(memoryPool_start + ((runningPointer - used_start) * bytes)));
		MEMPOOL_ASSERT2(((memoryPool_start + ((runningPointer - used_start) * bytes))) < memoryPool_end, "Returning pointer outside the high end of the pool");
		MEMPOOL_ASSERT2(((memoryPool_start + ((runningPointer - used_start) * bytes))) >= memoryPool_start, "Returning pointer outside the low end of the pool");
		const bool * const pre = runningPointer;
		if (++runningPointer >= used_end) runningPointer = used_start;
		return memoryPool_start + ((pre - used_start) * bytes);
	}
	
	void * _link_allocate(void) pool_nothrow {
		if (depth >= MEMPOOL_FALLBACK_DEPTH) return mempool_callbacks::allocate(bytes);
		if (!_link){
			_link = new(mempool_callbacks::allocate(sizeof(memory_pool_no_fullflag<bytes, size>))) memory_pool_no_fullflag<bytes, size>();
			_link -> depth = depth + 1;
		}
		return _link -> allocate();
	}

	size_t current;							//The current number of items in the pool
	size_t threshold;						//The number of items in the pool before it starts using fallback
	char memoryPool_start[size * bytes];	//The memory pool
	char * memoryPool_end;					//The end of the memory pool
	bool used_start[size];					//A pool to know whether or not an item is currently used
	bool * used_end;						//The end of the boolean flags
	bool * runningPointer;					//A pointer that loops, keeping an eye on what is taken and what isn't
	memory_pool_no_fullflag<bytes, size> * _link;		//Creates a linked list when expanding
	size_t depth;
};

template <size_t bytes, size_t size>
class memory_pool : public memory_pool_no_fullflag<bytes, size> {
public:
	memory_pool<bytes, size>() : 
	memory_pool_no_fullflag<bytes, size>(),
	_full(false){}
	
	virtual ~memory_pool(void){}
	
	inline void * allocate(void) pool_hot {
		if (_full) return mempool_callbacks::allocate(bytes);
		return memory_pool_no_fullflag<bytes, size>::allocate();
	}
	
	inline void deallocate(void * ptr) pool_hot {
		_full = false;
		return memory_pool_no_fullflag<bytes, size>::deallocate(ptr);
	}
	
	#ifdef MEMPOOL_PERFORMANCE_DEBUGGING
		const char * const getName(void){ return "memory_pool"; }
	#endif
private:
	//copy ctors and assignment operator
	memory_pool & operator = (const memory_pool & other);
	memory_pool(const memory_pool & other);
	
	bool _full;
	
	template <typename T, size_t s> friend class object_memory_pool;
};


//A memory pool for a specific type of object
#define new_object(pool, ctor) new (pool.allocate_noctor()) ctor  //allows user to call a specific ctor on the object [ new_object(mypool, T(x, y)) ] 
template <typename T, size_t size>
class object_memory_pool {
public:	
	inline size_t load(void) const pool_nothrow {
		return _pool.load();
	}
	
	virtual ~object_memory_pool() pool_nothrow { } //so that it can be overloaded
	
	inline T * allocate(void) pool_hot { return new (_pool.allocate()) T(); }
	inline void * allocate_noctor(void) pool_nothrow { return _pool.allocate(); }
	
	inline void deallocate(T * ptr) pool_hot {
		ptr -> ~T();
		_pool.deallocate(ptr);
	}
	
	inline memory_pool<sizeof(T), size> * contains(T * ptr) const pool_hot {
		return _pool.contains((void*)ptr);	
	}
	
	inline T * alloc_nofallback() pool_hot {
		if (void * res = _pool.allocate_nofallback()){
			return new (res) T();
		}
		return NULL;
	}
	
	inline void deallocate_nofallback(T * ptr) pool_hot {
		ptr -> ~T();
		_pool.deallocate_nofallback(ptr);
	}
	#ifdef MEMPOOL_PERFORMANCE_DEBUGGING
		const std::string dump(void){ return _pool.dump(); }
	#endif
private:
	memory_pool<sizeof(T), size> _pool;
};


#define MEMPOOL_TEMPLATE_PAIR(x) size_t bytes ## x , size_t count ## x
#define MEMPOOL_ALLOC_CHECK(x) if (bytes <= bytes ## x ){ if (void * res = (_pool ## x).allocate_nofallback()) return res; }
#define MEMPOOL_DEALLOC_CHECK(x) if (memory_pool_no_fullflag< bytes ## x , count ## x > * container = (_pool ## x).contains(ptr)){ container -> deallocate_nofallback(ptr); return; }
#define MEMPOOL_MEMBER_POOL(x) memory_pool< bytes ## x , count ## x > _pool ## x;

#define MEMPOOL_REALLOC_CHECK(x)\
	if (memory_pool_no_fullflag< bytes ## x , count ## x > * container = (_pool ## x).contains(ptr)){\
		if (bytes <= bytes ## x) return ptr;\
		void * newvalue = allocate(bytes);\
		std::memcpy(newvalue, ptr, bytes ## x);\
		container -> deallocate_nofallback(ptr);\
		return newvalue;\
	}


#ifdef MEMPOOL_DETERMINE_DISTRIBUTION
	#include <map>
	#include <iostream>
	#define MEMPOOL_ALLOC_METHOD(number, code)\
		bucket_pool_ ## number (void) : _profile_on_delete(0) { }\
		~bucket_pool_ ## number (void) { \
			if (_profile_on_delete){ \
				dump_atonce(_profile_on_delete, _profile_on_delete / 40); \
				dump_template(_profile_on_delete); \
			} \
		}\
		void * allocate(size_t bytes) pool_hot {\
			if (mapping.find(bytes) != mapping.end()){\
				++mapping[bytes];\
				++current_mapping[bytes];\
				if (current_mapping[bytes] > max_mapping[bytes]) max_mapping[bytes] = current_mapping[bytes];\
			} else {\
				mapping[bytes] = 1;\
				max_mapping[bytes] = 1;\
				current_mapping[bytes] = 1;\
			}\
			void * res = mempool_callbacks::allocate(bytes);\
			mem_mapping[res] = bytes;\
			return res;\
		}
	#define MEMPOOL_DEALLOC_METHOD(code)\
		void deallocate(void * ptr) pool_hot {\
			--current_mapping[mem_mapping[ptr]];\
			mem_mapping.erase(ptr);\
			mempool_callbacks::deallocate(ptr);\
		}
	
	#define MEMPOOL_ANALYZERS(macro_count)\
		inline size_t _max(size_t one, size_t two){ return (one > two) ? one : two; }\
		void dump_total(size_t max, size_t sep = 16, size_t tlen = 30){\
			std::cout << "-------- Total --------" << std::endl;\
			size_t max_amount = 0;\
			for(size_t i = 0; i < max;){\
				size_t amount = 0;\
				for(size_t j = 0; j < sep; ++j, ++i){\
					if (mapping.find(i) != mapping.end()){\
						amount += mapping[i];\
					}\
				}\
				if (amount > max_amount) max_amount = amount;\
			}\
			float scalar = ((float)max_amount) / ((float)tlen);\
			\
			for(size_t i = 0; i < max;){\
				size_t amount = 0;\
				for(size_t j = 0; j < sep; ++j, ++i){\
					if (mapping.find(i) != mapping.end()){\
						amount += mapping[i];\
					}\
				}\
				\
				if (i < 10) std::cout << ' ';\
				if (i < 100) std::cout << ' ';\
				if (i < 1000) std::cout << ' ';\
				if (i < 10000) std::cout << ' ';\
				std::cout << i << ':';\
				\
				for(size_t j = 0; j < (size_t)((float)amount / scalar); ++j){\
					std::cout << '*';\
				}\
				std::cout << '(' << amount << ')' << std::endl;\
			}\
		}\
		\
		void dump_atonce(size_t max, size_t sep = 16, size_t tlen = 30){\
			std::cout << "------ Distribution for \"" << _str << "\" ------" << std::endl;\
			size_t max_amount = 0;\
			for(size_t i = 0; i < max;){\
				size_t amount = 0;\
				for(size_t j = 0; j < sep; ++j, ++i){\
					if (max_mapping.find(i) != max_mapping.end()){\
						amount += max_mapping[i];\
					}\
				}\
				if (amount > max_amount) max_amount = amount;\
			}\
			float scalar = ((float)max_amount) / ((float)tlen);\
			\
			for(size_t i = 0; i < max;){\
				size_t amount = 0;\
				for(size_t j = 0; j < sep; ++j, ++i){\
					if (max_mapping.find(i) != max_mapping.end()){\
						amount += max_mapping[i];\
					}\
				}\
				\
				if (i < 10) std::cout << ' ';\
				if (i < 100) std::cout << ' ';\
				if (i < 1000) std::cout << ' ';\
				if (i < 10000) std::cout << ' ';\
				std::cout << i << ':';\
				\
				for(size_t j = 0; j < (size_t)((float)amount / scalar); ++j){\
					std::cout << '*';\
				}\
				std::cout << '(' << amount << ')' << std::endl;\
			}\
		}\
		\
		void dump_template(size_t max){\
			std::cout << "Recommended Template for \"" << _str << "\" = ";\
			size_t total_at_once = 0;\
			size_t highest = 0;\
			for(size_t i = 0; i < max; ++i){\
				if (max_mapping.find(i) != max_mapping.end()){\
					total_at_once += max_mapping[i];\
					highest = i;\
				}\
			}\
			\
			size_t count = 0;\
			size_t total_at_once_part = total_at_once / macro_count;\
			size_t current = 0;\
			size_t totalsofar = 0;\
			std::cout << '<';\
			for(size_t i = 0; ((i < max) && (count < (macro_count -1))); ++i){\
				if (max_mapping.find(i) != max_mapping.end()){\
					current += max_mapping[i];\
					totalsofar += max_mapping[i];\
					if (current > total_at_once_part){\
						std::cout << (i - 1)  << ", " << (size_t)(((float)current - max_mapping[i]) * (MEMPOOL_DETERMINE_SCALAR)) << ", ";\
						current = max_mapping[i];\
						++count;\
					}\
				}\
			}\
			std::cout << max << ", " << _max((size_t)((float)(total_at_once - totalsofar) * (MEMPOOL_DETERMINE_SCALAR)), total_at_once_part / 2) << '>' << std::endl;\
		}\
		\
		inline void profile_on_delete(size_t var, const std::string & str){ _profile_on_delete = var; _str = str; }

	#define MEMPOOL_MEMBERS(code)\
		 std::map<size_t, size_t> mapping;\
		 std::map<size_t, size_t> current_mapping;\
		 std::map<size_t, size_t> max_mapping;\
		 std::map<void *, size_t> mem_mapping;\
		 size_t _profile_on_delete;\
		 std::string _str;
	#define MEMPOOL_LOAD(number, code) inline size_t * load(void) const pool_nothrow { static size_t _load[number] = {0}; return &_load[0]; }
#else
	#define MEMPOOL_ALLOC_METHOD(number, code)\
		void * allocate(size_t bytes) pool_hot {\
			code\
			return mempool_callbacks::allocate(bytes);\
		}
	#define MEMPOOL_DEALLOC_METHOD(code)\
		void deallocate(void * ptr) pool_hot {\
			code\
			mempool_callbacks::deallocate(ptr);\
		}
	#define MEMPOOL_ANALYZERS(macro_count)
	#define MEMPOOL_MEMBERS(code) code
	#define MEMPOOL_LOAD(number, code) inline size_t * load(void) const pool_nothrow { static size_t _load[number]; code return &_load[0]; }
#endif

template<	
MEMPOOL_TEMPLATE_PAIR(1),
MEMPOOL_TEMPLATE_PAIR(2)>
class bucket_pool_2 {
public:
	MEMPOOL_ALLOC_METHOD(
		2,
		MEMPOOL_ALLOC_CHECK(1)
		MEMPOOL_ALLOC_CHECK(2)
	)
	void * reallocate(void * ptr, size_t bytes){
		MEMPOOL_REALLOC_CHECK(1)
		MEMPOOL_REALLOC_CHECK(2)
	}
	MEMPOOL_LOAD(
		2,
		_load[0] = _pool1.load();
		_load[1] = _pool2.load();
	)	
	MEMPOOL_DEALLOC_METHOD(
		MEMPOOL_DEALLOC_CHECK(1)
		MEMPOOL_DEALLOC_CHECK(2)
	)
	MEMPOOL_ANALYZERS(2)
private:
	MEMPOOL_MEMBERS(
		MEMPOOL_MEMBER_POOL(1)
		MEMPOOL_MEMBER_POOL(2)
	)
};

template<	
MEMPOOL_TEMPLATE_PAIR(1),
MEMPOOL_TEMPLATE_PAIR(2),
MEMPOOL_TEMPLATE_PAIR(3)>
class bucket_pool_3 {
public:
	MEMPOOL_ALLOC_METHOD(
		3,
		MEMPOOL_ALLOC_CHECK(1)
		MEMPOOL_ALLOC_CHECK(2)
		MEMPOOL_ALLOC_CHECK(3)
	)
	void * reallocate(void * ptr, size_t bytes){
		MEMPOOL_REALLOC_CHECK(1)
		MEMPOOL_REALLOC_CHECK(2)
		MEMPOOL_REALLOC_CHECK(3)
		return mempool_callbacks::reallocate(ptr, bytes);
	}
	MEMPOOL_LOAD(
		3,
		_load[0] = _pool1.load();
		_load[1] = _pool2.load();
		_load[2] = _pool3.load();
	)
	MEMPOOL_DEALLOC_METHOD(
		MEMPOOL_DEALLOC_CHECK(1)
		MEMPOOL_DEALLOC_CHECK(2)
		MEMPOOL_DEALLOC_CHECK(3)
	)
	MEMPOOL_ANALYZERS(3)
private:
	MEMPOOL_MEMBERS(
		MEMPOOL_MEMBER_POOL(1)
		MEMPOOL_MEMBER_POOL(2)
		MEMPOOL_MEMBER_POOL(3)
	)
};

template<	
MEMPOOL_TEMPLATE_PAIR(1),
MEMPOOL_TEMPLATE_PAIR(2),
MEMPOOL_TEMPLATE_PAIR(3),
MEMPOOL_TEMPLATE_PAIR(4)>
class bucket_pool_4 {
public:
	MEMPOOL_ALLOC_METHOD(
		4,
		MEMPOOL_ALLOC_CHECK(1)
		MEMPOOL_ALLOC_CHECK(2)
		MEMPOOL_ALLOC_CHECK(3)
		MEMPOOL_ALLOC_CHECK(4)
	)
	void * reallocate(void * ptr, size_t bytes){
        MEMPOOL_REALLOC_CHECK(1)
		MEMPOOL_REALLOC_CHECK(2)
		MEMPOOL_REALLOC_CHECK(3)
		MEMPOOL_REALLOC_CHECK(4)
		return mempool_callbacks::reallocate(ptr, bytes);
	}
	MEMPOOL_LOAD(
		4,
		_load[0] = _pool1.load();
		_load[1] = _pool2.load();
		_load[2] = _pool3.load();
		_load[3] = _pool4.load();
	)
	MEMPOOL_DEALLOC_METHOD(
		MEMPOOL_DEALLOC_CHECK(1)
		MEMPOOL_DEALLOC_CHECK(2)
		MEMPOOL_DEALLOC_CHECK(3)
		MEMPOOL_DEALLOC_CHECK(4)
	)
	MEMPOOL_ANALYZERS(4)
private:
	MEMPOOL_MEMBERS(
		MEMPOOL_MEMBER_POOL(1)
		MEMPOOL_MEMBER_POOL(2)
		MEMPOOL_MEMBER_POOL(3)
		MEMPOOL_MEMBER_POOL(4)
	)
};

template<	
MEMPOOL_TEMPLATE_PAIR(1),
MEMPOOL_TEMPLATE_PAIR(2),
MEMPOOL_TEMPLATE_PAIR(3),
MEMPOOL_TEMPLATE_PAIR(4),
MEMPOOL_TEMPLATE_PAIR(5)>
class bucket_pool_5 {
public:
	MEMPOOL_ALLOC_METHOD(
		5,
		MEMPOOL_ALLOC_CHECK(1)
		MEMPOOL_ALLOC_CHECK(2)
		MEMPOOL_ALLOC_CHECK(3)
		MEMPOOL_ALLOC_CHECK(4)
		MEMPOOL_ALLOC_CHECK(5)
	)
	void * reallocate(void * ptr, size_t bytes){
		MEMPOOL_REALLOC_CHECK(1)
		MEMPOOL_REALLOC_CHECK(2)
		MEMPOOL_REALLOC_CHECK(3)
		MEMPOOL_REALLOC_CHECK(4)
		MEMPOOL_REALLOC_CHECK(5)
		return mempool_callbacks::reallocate(ptr, bytes);
	}
	MEMPOOL_LOAD(
		5,
		_load[0] = _pool1.load();
		_load[1] = _pool2.load();
		_load[2] = _pool3.load();
		_load[3] = _pool4.load();
		_load[4] = _pool5.load();
	)
	MEMPOOL_DEALLOC_METHOD(
		MEMPOOL_DEALLOC_CHECK(1)
		MEMPOOL_DEALLOC_CHECK(2)
		MEMPOOL_DEALLOC_CHECK(3)
		MEMPOOL_DEALLOC_CHECK(4)
		MEMPOOL_DEALLOC_CHECK(5)
	)
	MEMPOOL_ANALYZERS(5)
private:
	MEMPOOL_MEMBERS(
		MEMPOOL_MEMBER_POOL(1)
		MEMPOOL_MEMBER_POOL(2)
		MEMPOOL_MEMBER_POOL(3)
		MEMPOOL_MEMBER_POOL(4)
		MEMPOOL_MEMBER_POOL(5)
	)
};

template<	
MEMPOOL_TEMPLATE_PAIR(1),
MEMPOOL_TEMPLATE_PAIR(2),
MEMPOOL_TEMPLATE_PAIR(3),
MEMPOOL_TEMPLATE_PAIR(4),
MEMPOOL_TEMPLATE_PAIR(5),
MEMPOOL_TEMPLATE_PAIR(6)>
class bucket_pool_6 {
public:
	MEMPOOL_ALLOC_METHOD(
		6,
		MEMPOOL_ALLOC_CHECK(1)
		MEMPOOL_ALLOC_CHECK(2)
		MEMPOOL_ALLOC_CHECK(3)
		MEMPOOL_ALLOC_CHECK(4)
		MEMPOOL_ALLOC_CHECK(5)
		MEMPOOL_ALLOC_CHECK(6)
	)
	void * reallocate(void * ptr, size_t bytes){
		MEMPOOL_REALLOC_CHECK(1)
		MEMPOOL_REALLOC_CHECK(2)
		MEMPOOL_REALLOC_CHECK(3)
		MEMPOOL_REALLOC_CHECK(4)
		MEMPOOL_REALLOC_CHECK(5)
		MEMPOOL_REALLOC_CHECK(6)
		return mempool_callbacks::reallocate(ptr, bytes);
	}
	MEMPOOL_LOAD(
		6,
		_load[0] = _pool1.load();
		_load[1] = _pool2.load();
		_load[2] = _pool3.load();
		_load[3] = _pool4.load();
		_load[4] = _pool5.load();
		_load[5] = _pool6.load();
	)
	MEMPOOL_DEALLOC_METHOD(
		MEMPOOL_DEALLOC_CHECK(1)
		MEMPOOL_DEALLOC_CHECK(2)
		MEMPOOL_DEALLOC_CHECK(3)
		MEMPOOL_DEALLOC_CHECK(4)
		MEMPOOL_DEALLOC_CHECK(5)
		MEMPOOL_DEALLOC_CHECK(6)
	)
	MEMPOOL_ANALYZERS(6)
private:
	MEMPOOL_MEMBERS(
		MEMPOOL_MEMBER_POOL(1)
		MEMPOOL_MEMBER_POOL(2)
		MEMPOOL_MEMBER_POOL(3)
		MEMPOOL_MEMBER_POOL(4)
		MEMPOOL_MEMBER_POOL(5)
		MEMPOOL_MEMBER_POOL(6)
	)
};

template<	
MEMPOOL_TEMPLATE_PAIR(1),
MEMPOOL_TEMPLATE_PAIR(2),
MEMPOOL_TEMPLATE_PAIR(3),
MEMPOOL_TEMPLATE_PAIR(4),
MEMPOOL_TEMPLATE_PAIR(5),
MEMPOOL_TEMPLATE_PAIR(6),
MEMPOOL_TEMPLATE_PAIR(7)>
class bucket_pool_7 {
public:
	MEMPOOL_ALLOC_METHOD(
		7,
		MEMPOOL_ALLOC_CHECK(1)
		MEMPOOL_ALLOC_CHECK(2)
		MEMPOOL_ALLOC_CHECK(3)
		MEMPOOL_ALLOC_CHECK(4)
		MEMPOOL_ALLOC_CHECK(5)
		MEMPOOL_ALLOC_CHECK(6)
		MEMPOOL_ALLOC_CHECK(7)
	)
	void * reallocate(void * ptr, size_t bytes){
		MEMPOOL_REALLOC_CHECK(1)
		MEMPOOL_REALLOC_CHECK(2)
		MEMPOOL_REALLOC_CHECK(3)
		MEMPOOL_REALLOC_CHECK(4)
		MEMPOOL_REALLOC_CHECK(5)
		MEMPOOL_REALLOC_CHECK(6)
		MEMPOOL_REALLOC_CHECK(7)
		return mempool_callbacks::reallocate(ptr, bytes);
	}
	MEMPOOL_LOAD(
		7,
		_load[0] = _pool1.load();
		_load[1] = _pool2.load();
		_load[2] = _pool3.load();
		_load[3] = _pool4.load();
		_load[4] = _pool5.load();
		_load[5] = _pool6.load();
		_load[6] = _pool7.load();
	)
	MEMPOOL_DEALLOC_METHOD(
		MEMPOOL_DEALLOC_CHECK(1)
		MEMPOOL_DEALLOC_CHECK(2)
		MEMPOOL_DEALLOC_CHECK(3)
		MEMPOOL_DEALLOC_CHECK(4)
		MEMPOOL_DEALLOC_CHECK(5)
		MEMPOOL_DEALLOC_CHECK(6)
		MEMPOOL_DEALLOC_CHECK(7)
	)
	MEMPOOL_ANALYZERS(7)
private:
	MEMPOOL_MEMBERS(
		MEMPOOL_MEMBER_POOL(1)
		MEMPOOL_MEMBER_POOL(2)
		MEMPOOL_MEMBER_POOL(3)
		MEMPOOL_MEMBER_POOL(4)
		MEMPOOL_MEMBER_POOL(5)
		MEMPOOL_MEMBER_POOL(6)
		MEMPOOL_MEMBER_POOL(7)
	)
};

template<	
MEMPOOL_TEMPLATE_PAIR(1),
MEMPOOL_TEMPLATE_PAIR(2),
MEMPOOL_TEMPLATE_PAIR(3),
MEMPOOL_TEMPLATE_PAIR(4),
MEMPOOL_TEMPLATE_PAIR(5),
MEMPOOL_TEMPLATE_PAIR(6),
MEMPOOL_TEMPLATE_PAIR(7),
MEMPOOL_TEMPLATE_PAIR(8)>
class bucket_pool_8 {
public:
	MEMPOOL_ALLOC_METHOD(
		8,
		MEMPOOL_ALLOC_CHECK(1)
		MEMPOOL_ALLOC_CHECK(2)
		MEMPOOL_ALLOC_CHECK(3)
		MEMPOOL_ALLOC_CHECK(4)
		MEMPOOL_ALLOC_CHECK(5)
		MEMPOOL_ALLOC_CHECK(6)
		MEMPOOL_ALLOC_CHECK(7)
		MEMPOOL_ALLOC_CHECK(8)
	)
	void * reallocate(void * ptr, size_t bytes){
		MEMPOOL_REALLOC_CHECK(1)
		MEMPOOL_REALLOC_CHECK(2)
		MEMPOOL_REALLOC_CHECK(3)
		MEMPOOL_REALLOC_CHECK(4)
		MEMPOOL_REALLOC_CHECK(5)
		MEMPOOL_REALLOC_CHECK(6)
		MEMPOOL_REALLOC_CHECK(7)
		MEMPOOL_REALLOC_CHECK(8)
		return mempool_callbacks::reallocate(ptr, bytes);
	}
	MEMPOOL_LOAD(
		8,
		_load[0] = _pool1.load();
		_load[1] = _pool2.load();
		_load[2] = _pool3.load();
		_load[3] = _pool4.load();
		_load[4] = _pool5.load();
		_load[5] = _pool6.load();
		_load[6] = _pool7.load();
		_load[7] = _pool8.load();
	)
	MEMPOOL_DEALLOC_METHOD(
		MEMPOOL_DEALLOC_CHECK(1)
		MEMPOOL_DEALLOC_CHECK(2)
		MEMPOOL_DEALLOC_CHECK(3)
		MEMPOOL_DEALLOC_CHECK(4)
		MEMPOOL_DEALLOC_CHECK(5)
		MEMPOOL_DEALLOC_CHECK(6)
		MEMPOOL_DEALLOC_CHECK(7)
		MEMPOOL_DEALLOC_CHECK(8)
	)
	MEMPOOL_ANALYZERS(8)
private:
	MEMPOOL_MEMBERS(
		MEMPOOL_MEMBER_POOL(1)
		MEMPOOL_MEMBER_POOL(2)
		MEMPOOL_MEMBER_POOL(3)
		MEMPOOL_MEMBER_POOL(4)
		MEMPOOL_MEMBER_POOL(5)
		MEMPOOL_MEMBER_POOL(6)
		MEMPOOL_MEMBER_POOL(7)
		MEMPOOL_MEMBER_POOL(8)
	)
};

template<	
MEMPOOL_TEMPLATE_PAIR(1),
MEMPOOL_TEMPLATE_PAIR(2),
MEMPOOL_TEMPLATE_PAIR(3),
MEMPOOL_TEMPLATE_PAIR(4),
MEMPOOL_TEMPLATE_PAIR(5),
MEMPOOL_TEMPLATE_PAIR(6),
MEMPOOL_TEMPLATE_PAIR(7),
MEMPOOL_TEMPLATE_PAIR(8),
MEMPOOL_TEMPLATE_PAIR(9)>
class bucket_pool_9 {
public:
	MEMPOOL_ALLOC_METHOD(
		9,
		MEMPOOL_ALLOC_CHECK(1)
		MEMPOOL_ALLOC_CHECK(2)
		MEMPOOL_ALLOC_CHECK(3)
		MEMPOOL_ALLOC_CHECK(4)
		MEMPOOL_ALLOC_CHECK(5)
		MEMPOOL_ALLOC_CHECK(6)
		MEMPOOL_ALLOC_CHECK(7)
		MEMPOOL_ALLOC_CHECK(8)
		MEMPOOL_ALLOC_CHECK(9)
	)
	void * reallocate(void * ptr, size_t bytes){
		MEMPOOL_REALLOC_CHECK(1)
		MEMPOOL_REALLOC_CHECK(2)
		MEMPOOL_REALLOC_CHECK(3)
		MEMPOOL_REALLOC_CHECK(4)
		MEMPOOL_REALLOC_CHECK(5)
		MEMPOOL_REALLOC_CHECK(6)
		MEMPOOL_REALLOC_CHECK(7)
		MEMPOOL_REALLOC_CHECK(8)
		MEMPOOL_REALLOC_CHECK(9)
		return mempool_callbacks::reallocate(ptr, bytes);
	}
	MEMPOOL_LOAD(
		9,
		_load[0] = _pool1.load();
		_load[1] = _pool2.load();
		_load[2] = _pool3.load();
		_load[3] = _pool4.load();
		_load[4] = _pool5.load();
		_load[5] = _pool6.load();
		_load[6] = _pool7.load();
		_load[7] = _pool8.load();
		_load[8] = _pool9.load();
	)
	MEMPOOL_DEALLOC_METHOD(
		MEMPOOL_DEALLOC_CHECK(1)
		MEMPOOL_DEALLOC_CHECK(2)
		MEMPOOL_DEALLOC_CHECK(3)
		MEMPOOL_DEALLOC_CHECK(4)
		MEMPOOL_DEALLOC_CHECK(5)
		MEMPOOL_DEALLOC_CHECK(6)
		MEMPOOL_DEALLOC_CHECK(7)
		MEMPOOL_DEALLOC_CHECK(8)
		MEMPOOL_DEALLOC_CHECK(9)
	)
	MEMPOOL_ANALYZERS(9)
private:
	MEMPOOL_MEMBERS(
		MEMPOOL_MEMBER_POOL(1)
		MEMPOOL_MEMBER_POOL(2)
		MEMPOOL_MEMBER_POOL(3)
		MEMPOOL_MEMBER_POOL(4)
		MEMPOOL_MEMBER_POOL(5)
		MEMPOOL_MEMBER_POOL(6)
		MEMPOOL_MEMBER_POOL(7)
		MEMPOOL_MEMBER_POOL(8)
		MEMPOOL_MEMBER_POOL(9)
	)
};

template<	
MEMPOOL_TEMPLATE_PAIR(1),
MEMPOOL_TEMPLATE_PAIR(2),
MEMPOOL_TEMPLATE_PAIR(3),
MEMPOOL_TEMPLATE_PAIR(4),
MEMPOOL_TEMPLATE_PAIR(5),
MEMPOOL_TEMPLATE_PAIR(6),
MEMPOOL_TEMPLATE_PAIR(7),
MEMPOOL_TEMPLATE_PAIR(8),
MEMPOOL_TEMPLATE_PAIR(9),
MEMPOOL_TEMPLATE_PAIR(10)>
class bucket_pool_10 {
public:
	MEMPOOL_ALLOC_METHOD(
		10,
		MEMPOOL_ALLOC_CHECK(1)
		MEMPOOL_ALLOC_CHECK(2)
		MEMPOOL_ALLOC_CHECK(3)
		MEMPOOL_ALLOC_CHECK(4)
		MEMPOOL_ALLOC_CHECK(5)
		MEMPOOL_ALLOC_CHECK(6)
		MEMPOOL_ALLOC_CHECK(7)
		MEMPOOL_ALLOC_CHECK(8)
		MEMPOOL_ALLOC_CHECK(9)
		MEMPOOL_ALLOC_CHECK(10)
	)
	void * reallocate(void * ptr, size_t bytes){
		MEMPOOL_REALLOC_CHECK(1)
		MEMPOOL_REALLOC_CHECK(2)
		MEMPOOL_REALLOC_CHECK(3)
		MEMPOOL_REALLOC_CHECK(4)
		MEMPOOL_REALLOC_CHECK(5)
		MEMPOOL_REALLOC_CHECK(6)
		MEMPOOL_REALLOC_CHECK(7)
		MEMPOOL_REALLOC_CHECK(8)
		MEMPOOL_REALLOC_CHECK(9)
		MEMPOOL_REALLOC_CHECK(10)
		return mempool_callbacks::reallocate(ptr, bytes);
	}
	MEMPOOL_LOAD(
		10,
		_load[0] = _pool1.load();
		_load[1] = _pool2.load();
		_load[2] = _pool3.load();
		_load[3] = _pool4.load();
		_load[4] = _pool5.load();
		_load[5] = _pool6.load();
		_load[6] = _pool7.load();
		_load[7] = _pool8.load();
		_load[8] = _pool9.load();
		_load[9] = _pool10.load();
	)
	MEMPOOL_DEALLOC_METHOD(
		MEMPOOL_DEALLOC_CHECK(1)
		MEMPOOL_DEALLOC_CHECK(2)
		MEMPOOL_DEALLOC_CHECK(3)
		MEMPOOL_DEALLOC_CHECK(4)
		MEMPOOL_DEALLOC_CHECK(5)
		MEMPOOL_DEALLOC_CHECK(6)
		MEMPOOL_DEALLOC_CHECK(7)
		MEMPOOL_DEALLOC_CHECK(8)
		MEMPOOL_DEALLOC_CHECK(9)
		MEMPOOL_DEALLOC_CHECK(10)
	)
	MEMPOOL_ANALYZERS(10)
private:
	MEMPOOL_MEMBERS(
		MEMPOOL_MEMBER_POOL(1)
		MEMPOOL_MEMBER_POOL(2)
		MEMPOOL_MEMBER_POOL(3)
		MEMPOOL_MEMBER_POOL(4)
		MEMPOOL_MEMBER_POOL(5)
		MEMPOOL_MEMBER_POOL(6)
		MEMPOOL_MEMBER_POOL(7)
		MEMPOOL_MEMBER_POOL(8)
		MEMPOOL_MEMBER_POOL(9)
		MEMPOOL_MEMBER_POOL(10)
	)
};

#endif