diff --git a/Dependencies/imgui/imgui/IconsFontAwesome6.h b/Dependencies/imgui/imgui/IconsFontAwesome6.h
index bc9a9a27..ef62c66f 100644
--- a/Dependencies/imgui/imgui/IconsFontAwesome6.h
+++ b/Dependencies/imgui/imgui/IconsFontAwesome6.h
@@ -3,8 +3,30 @@
 // for use with https://github.com/FortAwesome/Font-Awesome/blob/6.x/webfonts/fa-regular-400.ttf, https://github.com/FortAwesome/Font-Awesome/blob/6.x/webfonts/fa-solid-900.ttf
 #pragma once
 
-#define FONT_ICON_FILE_NAME_FAR "fa-regular-400.ttf"
-#define FONT_ICON_FILE_NAME_FAS "fa-solid-900.ttf"
+/**
+ * WARNING
+ * 
+ * If used with cmake, replace the following lines:
+ * 
+ * #define FONT_ICON_FILE_NAME_FAR "./fonts/fa-regular-400.ttf"
+ * #define FONT_ICON_FILE_NAME_FAS "./fonts/fa-solid-900.ttf"
+ * 
+ * with:
+ * 
+ * #if _WIN32
+ * #define FONT_ICON_FILE_NAME_FAR "../../fonts/fa-regular-400.ttf"
+ * #define FONT_ICON_FILE_NAME_FAS "../../fonts/fa-solid-900.ttf"
+ * #else
+ * #define FONT_ICON_FILE_NAME_FAR "../fonts/fa-regular-400.ttf"
+ * #define FONT_ICON_FILE_NAME_FAS "../fonts/fa-solid-900.ttf"
+*/
+
+#define FONT_ICON_FILE_NAME_FAR "../../fonts/fa-regular-400.ttf"
+#define FONT_ICON_FILE_NAME_FAS "../../fonts/fa-solid-900.ttf"
+
+
+
+
 
 #define ICON_MIN_FA 0xe005
 #define ICON_MAX_16_FA 0xf8ff
diff --git a/Dependencies/imgui/imgui/ImGuiNotify.hpp b/Dependencies/imgui/imgui/ImGuiNotify.hpp
new file mode 100644
index 00000000..852e0ae8
--- /dev/null
+++ b/Dependencies/imgui/imgui/ImGuiNotify.hpp
@@ -0,0 +1,655 @@
+/**
+ * @file ImGuiNotify.hpp
+ * @brief A header-only library for creating toast notifications with ImGui.
+ * 
+ * Based on imgui-notify by patrickcjk
+ * https://github.com/patrickcjk/imgui-notify
+ * 
+ * @version 0.0.3 WIP by TyomaVader
+ * @date 18.01.2024
+ */
+
+#ifndef IMGUI_NOTIFY
+#define IMGUI_NOTIFY
+
+#pragma once
+
+#include <vector>			// Vector for storing notifications list
+#include <string>
+#include <chrono>			// For the notifications timed dissmiss
+#include <functional>		// For storing the code, which executest on the button click in the notification
+
+#include "imgui.h"
+#include "imgui_internal.h"
+
+#include "IconsFontAwesome6.h"
+
+
+
+
+
+
+
+
+
+/**
+ * CONFIGURATION SECTION Start
+*/
+
+#define NOTIFY_MAX_MSG_LENGTH				4096		// Max message content length
+#define NOTIFY_PADDING_X					20.f		// Bottom-left X padding
+#define NOTIFY_PADDING_Y					20.f		// Bottom-left Y padding
+#define NOTIFY_PADDING_MESSAGE_Y			10.f		// Padding Y between each message
+#define NOTIFY_FADE_IN_OUT_TIME				150			// Fade in and out duration
+#define NOTIFY_DEFAULT_DISMISS				3000		// Auto dismiss after X ms (default, applied only of no data provided in constructors)
+#define NOTIFY_OPACITY						0.8f		// 0-1 Toast opacity
+#define NOTIFY_USE_SEPARATOR 				false 		// If true, a separator will be rendered between the title and the content
+#define NOTIFY_USE_DISMISS_BUTTON			true		// If true, a dismiss button will be rendered in the top right corner of the toast
+#define NOTIFY_RENDER_LIMIT					5			// Max number of toasts rendered at the same time. Set to 0 for unlimited
+
+/**
+ * CONFIGURATION SECTION End
+*/
+
+
+
+
+
+
+
+
+static const ImGuiWindowFlags NOTIFY_DEFAULT_TOAST_FLAGS = ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoFocusOnAppearing;
+
+#define NOTIFY_NULL_OR_EMPTY(str)		(!str || !strlen(str))
+#define NOTIFY_FORMAT(fn, format, ...)	if (format) {va_list args; va_start(args, format); fn(format, args, ##__VA_ARGS__); va_end(args);}
+
+enum class ImGuiToastType : uint8_t
+{
+	None,
+	Success,
+	Warning,
+	Error,
+	Info,
+	COUNT
+};
+
+enum class ImGuiToastPhase : uint8_t
+{
+	FadeIn,
+	Wait,
+	FadeOut,
+	Expired,
+	COUNT
+};
+
+enum class ImGuiToastPos : uint8_t
+{
+	TopLeft,
+	TopCenter,
+	TopRight,
+	BottomLeft,
+	BottomCenter,
+	BottomRight,
+	Center,
+	COUNT
+};
+
+/**
+ * @brief A class for creating toast notifications with ImGui.
+ */
+class ImGuiToast
+{
+private:
+	ImGuiWindowFlags							flags = NOTIFY_DEFAULT_TOAST_FLAGS;
+
+	ImGuiToastType								type = ImGuiToastType::None;
+	char										title[NOTIFY_MAX_MSG_LENGTH];
+	char										content[NOTIFY_MAX_MSG_LENGTH];
+
+	int											dismissTime = NOTIFY_DEFAULT_DISMISS;
+	std::chrono::system_clock::time_point		creationTime = std::chrono::system_clock::now();
+
+	std::function<void()>						onButtonPress = nullptr; // A lambda variable, which will be executed when button in notification is pressed
+	char 										buttonLabel[NOTIFY_MAX_MSG_LENGTH];
+
+private:
+	// Setters
+
+	inline void setTitle(const char* format, va_list args)
+	{
+		vsnprintf(this->title, sizeof(this->title), format, args);
+	}
+
+	inline void setContent(const char* format, va_list args)
+	{
+		vsnprintf(this->content, sizeof(this->content), format, args);
+	}
+
+	inline void setButtonLabel(const char* format, va_list args)
+	{
+		vsnprintf(this->buttonLabel, sizeof(this->buttonLabel), format, args);
+	}
+
+public:
+
+	/**
+	 * @brief Set the title of the toast notification.
+	 * 
+	 * @param format The format string for the title.
+	 * @param ... The arguments for the format string.
+	 */
+	inline void setTitle(const char* format, ...)
+	{
+		NOTIFY_FORMAT(this->setTitle, format);
+	}
+
+	/**
+	 * @brief Set the content of the toast notification.
+	 * 
+	 * @param format The format string for the content.
+	 * @param ... The arguments for the format string.
+	 */
+	inline void setContent(const char* format, ...)
+	{
+		NOTIFY_FORMAT(this->setContent, format);
+	}
+
+	/**
+	 * @brief Set the type of the toast notification.
+	 * 
+	 * @param type The type of the toast notification.
+	 */
+	inline void setType(const ImGuiToastType& type)
+	{
+		IM_ASSERT(type < ImGuiToastType::COUNT);
+		this->type = type;
+	};
+
+	/**
+	 * @brief Set the ImGui window flags for the notification.
+	 * 
+	 * @param flags ImGui window flags to set.
+	*/
+	inline void setWindowFlags(const ImGuiWindowFlags& flags)
+	{
+		this->flags = flags;
+	}
+
+	/**
+	 * @brief Set the function to run on the button click in the notification.
+	 * 
+	 * @param onButtonPress std::fuction or lambda expression, which contains the code for execution.
+	*/
+	inline void setOnButtonPress(const std::function<void()>& onButtonPress)
+	{
+		this->onButtonPress = onButtonPress;
+	}
+
+	/**
+	 * @brief Set the label for the button in the notification.
+	 * 
+	 * @param format The format string for the label.
+	 * @param ... The arguments for the format string.
+	*/
+	inline void setButtonLabel(const char* format, ...)
+	{
+		NOTIFY_FORMAT(this->setButtonLabel, format);
+	}
+
+public:
+	// Getters
+
+	/**
+	 * @brief Get the title of the toast notification.
+	 * 
+	 * @return const char* The title of the toast notification.
+	 */
+	inline const char* getTitle()
+	{
+		return this->title;
+	};
+
+	/**
+	 * @brief Get the default title of the toast notification based on its type.
+	 * 
+	 * @return const char* The default title of the toast notification.
+	 */
+	inline const char* getDefaultTitle()
+	{
+		if (!strlen(this->title))
+		{
+			switch (this->type)
+			{
+			case ImGuiToastType::None:
+				return nullptr;
+			case ImGuiToastType::Success:
+				return "Success";
+			case ImGuiToastType::Warning:
+				return "Warning";
+			case ImGuiToastType::Error:
+				return "Error";
+			case ImGuiToastType::Info:
+				return "Info";
+			default:
+				return nullptr;
+			}
+		}
+
+		return this->title;
+	};
+
+	/**
+	 * @brief Get the type of the toast notification.
+	 * 
+	 * @return ImGuiToastType The type of the toast notification.
+	 */
+	inline ImGuiToastType getType()
+	{
+		return this->type;
+	};
+
+	/**
+	 * @brief Get the color of the toast notification based on its type.
+	 * 
+	 * @return ImVec4 The color of the toast notification.
+	 */
+	inline ImVec4 getColor()
+	{
+		switch (this->type)
+		{
+		case ImGuiToastType::None:
+			return {255, 255, 255, 255}; // White
+		case ImGuiToastType::Success:
+			return {0, 255, 0, 255}; // Green
+		case ImGuiToastType::Warning:
+			return {255, 255, 0, 255}; // Yellow
+		case ImGuiToastType::Error:
+			return {255, 0, 0, 255}; // Error
+		case ImGuiToastType::Info:
+			return {0, 157, 255, 255}; // Blue
+		default:
+			return {255, 255, 255, 255}; // White
+		}
+	}
+
+	/**
+	 * @brief Get the icon of the toast notification based on its type.
+	 * 
+	 * @return const char* The icon of the toast notification.
+	 */
+	inline const char* getIcon() 
+	{
+		switch (this->type)
+		{
+		case ImGuiToastType::None:
+			return nullptr;
+		case ImGuiToastType::Success:
+			return ICON_FA_CIRCLE_CHECK; // Font Awesome 6
+		case ImGuiToastType::Warning:
+			return ICON_FA_TRIANGLE_EXCLAMATION; // Font Awesome 6
+		case ImGuiToastType::Error:
+			return ICON_FA_CIRCLE_EXCLAMATION; // Font Awesome 6
+		case ImGuiToastType::Info:
+			return ICON_FA_CIRCLE_INFO; // Font Awesome 6
+		default:
+			return nullptr;
+		}
+	}
+
+	/**
+	 * @brief Get the content of the toast notification.
+	 * 
+	 * @return char* The content of the toast notification.
+	 */
+	inline char* getContent() 
+	{
+		return this->content;
+	};
+
+	/**
+	 * @brief Get the elapsed time in milliseconds since the creation of the object.
+	 * 
+	 * @return int64_t The elapsed time in milliseconds.
+	 * @throws An exception with the message "Unsupported platform" if the platform is not supported.
+	 */
+	inline std::chrono::nanoseconds getElapsedTime() 
+	{
+		return std::chrono::system_clock::now() - this->creationTime;
+	}
+
+	/**
+	 * @brief Get the current phase of the toast notification based on the elapsed time since its creation.
+	 * 
+	 * @return ImGuiToastPhase The current phase of the toast notification.
+	 *         - ImGuiToastPhase::FadeIn: The notification is fading in.
+	 *         - ImGuiToastPhase::Wait: The notification is waiting to be dismissed.
+	 *         - ImGuiToastPhase::FadeOut: The notification is fading out.
+	 *         - ImGuiToastPhase::Expired: The notification has expired and should be removed.
+	 */
+	inline ImGuiToastPhase getPhase()
+	{
+		const int64_t elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(getElapsedTime()).count();
+
+		if (elapsed > NOTIFY_FADE_IN_OUT_TIME + this->dismissTime + NOTIFY_FADE_IN_OUT_TIME)
+		{
+			return ImGuiToastPhase::Expired;
+		} else 
+		if (elapsed > NOTIFY_FADE_IN_OUT_TIME + this->dismissTime)
+		{
+			return ImGuiToastPhase::FadeOut;
+		} else 
+		if (elapsed > NOTIFY_FADE_IN_OUT_TIME)
+		{
+			return ImGuiToastPhase::Wait;
+		} else
+		{
+			return ImGuiToastPhase::FadeIn;
+		}
+	}
+
+	/**
+	 * Returns the percentage of fade for the notification.
+	 * @return The percentage of fade for the notification.
+	 */
+	inline float getFadePercent()
+	{
+		const ImGuiToastPhase phase = getPhase();
+		const int64_t elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(getElapsedTime()).count();
+
+		if (phase == ImGuiToastPhase::FadeIn)
+		{
+			return ((float)elapsed / (float)NOTIFY_FADE_IN_OUT_TIME) * NOTIFY_OPACITY;
+		} else 
+		if (phase == ImGuiToastPhase::FadeOut)
+		{
+			return (1.f - (((float)elapsed - (float)NOTIFY_FADE_IN_OUT_TIME - (float)this->dismissTime) / (float)NOTIFY_FADE_IN_OUT_TIME)) * NOTIFY_OPACITY;
+		}
+
+		return 1.f * NOTIFY_OPACITY;
+	}
+
+	/**
+	 * @return ImGui window flags for the notification.
+	*/
+	inline ImGuiWindowFlags getWindowFlags()
+	{
+		return this->flags;
+	}
+
+	/**
+	 * @return The function, which is executed on the button click in the notification.
+	*/
+	inline std::function<void()> getOnButtonPress()
+	{
+		return this->onButtonPress;
+	}
+
+	/**
+	 * @return The label on the button in notification.
+	*/
+	inline const char* getButtonLabel()
+	{
+		return this->buttonLabel;
+	}
+
+public:
+	// Constructors
+
+	/**
+	 * @brief Creates a new ImGuiToast object with the specified type and dismiss time.
+	 * 
+	 * @param type The type of the toast.
+	 * @param dismissTime The time in milliseconds after which the toast should be dismissed. Default is NOTIFY_DEFAULT_DISMISS.
+	 */
+	ImGuiToast(ImGuiToastType type, int dismissTime = NOTIFY_DEFAULT_DISMISS)
+	{
+		IM_ASSERT(type < ImGuiToastType::COUNT);
+
+		this->type = type;
+		this->dismissTime = dismissTime;
+
+		this->creationTime = std::chrono::system_clock::now();
+
+		memset(this->title, 0, sizeof(this->title));
+		memset(this->content, 0, sizeof(this->content));
+	}
+
+	/**
+	 * @brief Constructor for creating an ImGuiToast object with a specified type and message format.
+	 * 
+	 * @param type The type of the toast message.
+	 * @param format The format string for the message.
+	 * @param ... The variable arguments to be formatted according to the format string.
+	 */
+	ImGuiToast(ImGuiToastType type, const char* format, ...) : ImGuiToast(type)
+	{
+		NOTIFY_FORMAT(this->setContent, format);
+	}
+
+	/**
+	 * @brief Constructor for creating a new ImGuiToast object with a specified type, dismiss time, and content format.
+	 * 
+	 * @param type The type of the toast message.
+	 * @param dismissTime The time in milliseconds before the toast message is dismissed.
+	 * @param format The format string for the content of the toast message.
+	 * @param ... The variable arguments to be formatted according to the format string.
+	 */
+	ImGuiToast(ImGuiToastType type, int dismissTime, const char* format, ...) : ImGuiToast(type, dismissTime)
+	{
+		NOTIFY_FORMAT(this->setContent, format);
+	}
+
+	/**
+	 * @brief Constructor for creating a new ImGuiToast object with a specified type, dismiss time, title format, content format and a button.
+	 * 
+	 * @param type The type of the toast message.
+	 * @param dismissTime The time in milliseconds before the toast message is dismissed.
+	 * @param buttonLabel The label for the button.
+	 * @param onButtonPress The lambda function to be executed when the button is pressed.
+	 * @param format The format string for the content of the toast message.
+	 * @param ... The variable arguments to be formatted according to the format string.
+	 */
+	ImGuiToast(ImGuiToastType type, int dismissTime, const char* buttonLabel, const std::function<void()>& onButtonPress, const char* format, ...) : ImGuiToast(type, dismissTime)
+	{
+		NOTIFY_FORMAT(this->setContent, format);
+
+		this->onButtonPress = onButtonPress;
+		this->setButtonLabel(buttonLabel);
+	}
+};
+
+namespace ImGui
+{
+	inline std::vector<ImGuiToast> notifications;
+
+	/**
+	 * Inserts a new notification into the notification queue.
+	 * @param toast The notification to be inserted.
+	 */
+	inline void InsertNotification(const ImGuiToast& toast)
+	{
+		notifications.push_back(toast);
+	}
+
+	/**
+	 * @brief Removes a notification from the list of notifications.
+	 * 
+	 * @param index The index of the notification to remove.
+	 */
+	inline void RemoveNotification(int index)
+	{
+		notifications.erase(notifications.begin() + index);
+	}
+
+
+	/**
+	 * Renders all notifications in the notifications vector.
+	 * Each notification is rendered as a toast window with a title, content and an optional icon.
+	 * If a notification is expired, it is removed from the vector.
+	 */
+	inline void RenderNotifications()
+	{
+		const ImVec2 mainWindowSize = GetMainViewport()->Size;
+
+		float height = 0.f;
+
+		int numNotifications = static_cast<int>(notifications.size());
+		for (int i = 0; i < numNotifications; ++i)
+		{
+			ImGuiToast* currentToast = &notifications[i];
+
+			// Remove toast if expired
+			if (currentToast->getPhase() == ImGuiToastPhase::Expired)
+			{
+				RemoveNotification(i);
+				continue;
+			}
+
+			#if NOTIFY_RENDER_LIMIT > 0
+				if (i > NOTIFY_RENDER_LIMIT)
+				{
+					continue;
+				}
+			#endif
+
+			// Get icon, title and other data
+			const char* icon = currentToast->getIcon();
+			const char* title = currentToast->getTitle();
+			const char* content = currentToast->getContent();
+			const char* defaultTitle = currentToast->getDefaultTitle();
+			const float opacity = currentToast->getFadePercent(); // Get opacity based of the current phase
+
+			// Window rendering
+			ImVec4 textColor = currentToast->getColor();
+			textColor.w = opacity;
+
+			// Generate new unique name for this toast
+			char windowName[50];
+			#ifdef _WIN32
+				sprintf_s(windowName, "##TOAST%d", (int)i);
+			#elif defined(__linux__) || defined(__EMSCRIPTEN__)
+				sprintf(windowName, "##TOAST%d", (int)i);
+			#else
+				throw "Unsupported platform";
+			#endif
+
+			//PushStyleColor(ImGuiCol_Text, textColor);
+			SetNextWindowBgAlpha(opacity);
+
+			// Set notification window position to bottom right corner of the main window, considering the main window size and location in relation to the display
+			ImVec2 mainWindowPos = GetMainViewport()->Pos;
+			SetNextWindowPos(ImVec2(mainWindowPos.x + mainWindowSize.x - NOTIFY_PADDING_X, mainWindowPos.y + mainWindowSize.y - NOTIFY_PADDING_Y - height), ImGuiCond_Always, ImVec2(1.0f, 1.0f));
+
+			// Set notification window flags
+			if (!NOTIFY_USE_DISMISS_BUTTON && currentToast->getOnButtonPress() == nullptr)
+			{
+				currentToast->setWindowFlags(NOTIFY_DEFAULT_TOAST_FLAGS | ImGuiWindowFlags_NoInputs);
+			}
+
+			Begin(windowName, nullptr, currentToast->getWindowFlags());
+
+			// Render over all other windows
+			BringWindowToDisplayFront(GetCurrentWindow());
+
+			// Here we render the toast content
+			{
+				PushTextWrapPos(mainWindowSize.x / 3.f); // We want to support multi-line text, this will wrap the text after 1/3 of the screen width
+
+				bool wasTitleRendered = false;
+
+				// If an icon is set
+				if (!NOTIFY_NULL_OR_EMPTY(icon))
+				{
+					//Text(icon); // Render icon text
+					TextColored(textColor, "%s", icon);
+					wasTitleRendered = true;
+				}
+
+				// If a title is set
+				if (!NOTIFY_NULL_OR_EMPTY(title))
+				{
+					// If a title and an icon is set, we want to render on same line
+					if (!NOTIFY_NULL_OR_EMPTY(icon))
+						SameLine();
+
+					Text("%s", title); // Render title text
+					wasTitleRendered = true;
+				} else 
+				if (!NOTIFY_NULL_OR_EMPTY(defaultTitle))
+				{
+					if (!NOTIFY_NULL_OR_EMPTY(icon))
+						SameLine();
+
+					Text("%s", defaultTitle); // Render default title text (ImGuiToastType_Success -> "Success", etc...)
+					wasTitleRendered = true;
+				}
+
+				// If a dismiss button is enabled
+				if (NOTIFY_USE_DISMISS_BUTTON)
+				{
+					// If a title or content is set, we want to render the button on the same line
+					if (wasTitleRendered || !NOTIFY_NULL_OR_EMPTY(content))
+					{
+						SameLine();
+					}
+
+					// Render the dismiss button on the top right corner
+					// NEEDS TO BE REWORKED
+					float scale = 0.8f;
+
+					if (CalcTextSize(content).x > GetWindowContentRegionMax().x)
+					{
+						scale = 0.95f;
+					}
+
+					SetCursorPosX(GetCursorPosX() + (GetWindowSize().x - GetCursorPosX()) * scale);
+
+					// If the button is pressed, we want to remove the notification
+					if (Button(ICON_FA_XMARK))
+					{
+						RemoveNotification(i);
+					}
+				}
+
+				// In case ANYTHING was rendered in the top, we want to add a small padding so the text (or icon) looks centered vertically
+				if (wasTitleRendered && !NOTIFY_NULL_OR_EMPTY(content))
+				{
+					SetCursorPosY(GetCursorPosY() + 5.f); // Must be a better way to do this!!!!
+				}
+
+				// If a content is set
+				if (!NOTIFY_NULL_OR_EMPTY(content))
+				{
+					if (wasTitleRendered)
+					{
+						#if NOTIFY_USE_SEPARATOR
+							Separator();
+						#endif
+					}
+
+					Text("%s", content); // Render content text
+				}
+
+				// If a button is set
+				if (currentToast->getOnButtonPress() != nullptr)
+				{
+					// If the button is pressed, we want to execute the lambda function
+					if (Button(currentToast->getButtonLabel()))
+					{
+						currentToast->getOnButtonPress()();
+					}
+				}
+
+				PopTextWrapPos();
+			}
+
+			// Save height for next toasts
+			height += GetWindowHeight() + NOTIFY_PADDING_MESSAGE_Y;
+
+			// End
+			End();
+		}
+	}
+}
+
+#endif
\ No newline at end of file
diff --git a/Dependencies/imgui/imgui/LICENSE_ImguiNotify.txt b/Dependencies/imgui/imgui/LICENSE_ImguiNotify.txt
new file mode 100644
index 00000000..aa5d5993
--- /dev/null
+++ b/Dependencies/imgui/imgui/LICENSE_ImguiNotify.txt
@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Patrick
+Copyright (c) 2023 TyomaVader
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/Dependencies/imgui/imgui/imgui_notify.h b/Dependencies/imgui/imgui/imgui_notify.h
deleted file mode 100644
index 83c02396..00000000
--- a/Dependencies/imgui/imgui/imgui_notify.h
+++ /dev/null
@@ -1,648 +0,0 @@
-/**
- * @file ImGuiNotify.hpp
- * @brief A header-only library for creating toast notifications with ImGui.
- *
- * Based on imgui-notify by patrickcjk
- * https://github.com/patrickcjk/imgui-notify
- *
- * @version 0.0.1 by TyomaVader
- * @date 28.07.2023
- */
-
-#ifndef IMGUI_NOTIFY
-#define IMGUI_NOTIFY
-
-#pragma once
-
-#include <vector>			// Vector for storing notifications list
-#include <string>
-#include <chrono>			// For the notifications timed dissmiss
-#include <functional>		// For storing the code, which executest on the button click in the notification
-
-#include "imgui.h"
-#include "imgui_internal.h"
-
-#include "IconsFontAwesome6.h"
-#include "fa_solid_900.h"
-
-
-
-
-
-
-
-
-
-/**
- * CONFIGURATION SECTION Start
-*/
-
-#define NOTIFY_MAX_MSG_LENGTH			4096		// Max message content length
-#define NOTIFY_PADDING_X				20.f		// Bottom-left X padding
-#define NOTIFY_PADDING_Y				20.f		// Bottom-left Y padding
-#define NOTIFY_PADDING_MESSAGE_Y		10.f		// Padding Y between each message
-#define NOTIFY_FADE_IN_OUT_TIME			150			// Fade in and out duration
-#define NOTIFY_DEFAULT_DISMISS			3000		// Auto dismiss after X ms (default, applied only of no data provided in constructors)
-#define NOTIFY_OPACITY					0.8f		// 0-1 Toast opacity
-#define NOTIFY_USE_SEPARATOR 			false 		// If true, a separator will be rendered between the title and the content
-#define NOTIFY_USE_DISMISS_BUTTON		true		// If true, a dismiss button will be rendered in the top right corner of the toast
-
-
-/**
- * CONFIGURATION SECTION End
-*/
-
-
-
-
-
-
-
-
-static const ImGuiWindowFlags NOTIFY_DEFAULT_TOAST_FLAGS = ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoFocusOnAppearing;
-
-#define NOTIFY_NULL_OR_EMPTY(str)		(!str || !strlen(str))
-#define NOTIFY_FORMAT(fn, format, ...)	if (format) {va_list args; va_start(args, format); fn(format, args, ##__VA_ARGS__); va_end(args);}
-
-enum class ImGuiToastType : uint8_t
-{
-    None,
-    Success,
-    Warning,
-    Error,
-    Info,
-    COUNT
-};
-
-enum class ImGuiToastPhase : uint8_t
-{
-    FadeIn,
-    Wait,
-    FadeOut,
-    Expired,
-    COUNT
-};
-
-enum class ImGuiToastPos : uint8_t
-{
-    TopLeft,
-    TopCenter,
-    TopRight,
-    BottomLeft,
-    BottomCenter,
-    BottomRight,
-    Center,
-    COUNT
-};
-
-/**
- * @brief A class for creating toast notifications with ImGui.
- */
-class ImGuiToast
-{
-private:
-    ImGuiWindowFlags							flags = NOTIFY_DEFAULT_TOAST_FLAGS;
-
-    ImGuiToastType								type = ImGuiToastType::None;
-    char										title[NOTIFY_MAX_MSG_LENGTH];
-    char										content[NOTIFY_MAX_MSG_LENGTH];
-
-    int											dismissTime = NOTIFY_DEFAULT_DISMISS;
-    std::chrono::system_clock::time_point		creationTime = std::chrono::system_clock::now();
-
-    std::function<void()>						onButtonPress = nullptr; // A lambda variable, which will be executed when button in notification is pressed
-    char 										buttonLabel[NOTIFY_MAX_MSG_LENGTH];
-
-private:
-    // Setters
-
-    inline void setTitle(const char* format, va_list args)
-    {
-        vsnprintf(this->title, sizeof(this->title), format, args);
-    }
-
-    inline void setContent(const char* format, va_list args)
-    {
-        vsnprintf(this->content, sizeof(this->content), format, args);
-    }
-
-    inline void setButtonLabel(const char* format, va_list args)
-    {
-        vsnprintf(this->buttonLabel, sizeof(this->buttonLabel), format, args);
-    }
-
-public:
-
-    /**
-     * @brief Set the title of the toast notification.
-     *
-     * @param format The format string for the title.
-     * @param ... The arguments for the format string.
-     */
-    inline void setTitle(const char* format, ...)
-    {
-        NOTIFY_FORMAT(this->setTitle, format);
-    }
-
-    /**
-     * @brief Set the content of the toast notification.
-     *
-     * @param format The format string for the content.
-     * @param ... The arguments for the format string.
-     */
-    inline void setContent(const char* format, ...)
-    {
-        NOTIFY_FORMAT(this->setContent, format);
-    }
-
-    /**
-     * @brief Set the type of the toast notification.
-     *
-     * @param type The type of the toast notification.
-     */
-    inline void setType(const ImGuiToastType& type)
-    {
-        IM_ASSERT(type < ImGuiToastType::COUNT);
-        this->type = type;
-    };
-
-    /**
-     * @brief Set the ImGui window flags for the notification.
-     *
-     * @param flags ImGui window flags to set.
-    */
-    inline void setWindowFlags(const ImGuiWindowFlags& flags)
-    {
-        this->flags = flags;
-    }
-
-    /**
-     * @brief Set the function to run on the button click in the notification.
-     *
-     * @param onButtonPress std::fuction or lambda expression, which contains the code for execution.
-    */
-    inline void setOnButtonPress(const std::function<void()>& onButtonPress)
-    {
-        this->onButtonPress = onButtonPress;
-    }
-
-    /**
-     * @brief Set the label for the button in the notification.
-     *
-     * @param format The format string for the label.
-     * @param ... The arguments for the format string.
-    */
-    inline void setButtonLabel(const char* format, ...)
-    {
-        NOTIFY_FORMAT(this->setButtonLabel, format);
-    }
-
-public:
-    // Getters
-
-    /**
-     * @brief Get the title of the toast notification.
-     *
-     * @return const char* The title of the toast notification.
-     */
-    inline const char* getTitle()
-    {
-        return this->title;
-    };
-
-    /**
-     * @brief Get the default title of the toast notification based on its type.
-     *
-     * @return const char* The default title of the toast notification.
-     */
-    inline const char* getDefaultTitle()
-    {
-        if (!strlen(this->title))
-        {
-            switch (this->type)
-            {
-                case ImGuiToastType::None:
-                    return nullptr;
-                case ImGuiToastType::Success:
-                    return "Success";
-                case ImGuiToastType::Warning:
-                    return "Warning";
-                case ImGuiToastType::Error:
-                    return "Error";
-                case ImGuiToastType::Info:
-                    return "Info";
-                default:
-                    return nullptr;
-            }
-        }
-
-        return this->title;
-    };
-
-    /**
-     * @brief Get the type of the toast notification.
-     *
-     * @return ImGuiToastType The type of the toast notification.
-     */
-    inline ImGuiToastType getType()
-    {
-        return this->type;
-    };
-
-    /**
-     * @brief Get the color of the toast notification based on its type.
-     *
-     * @return ImVec4 The color of the toast notification.
-     */
-    inline ImVec4 getColor()
-    {
-        switch (this->type)
-        {
-            case ImGuiToastType::None:
-                return {255, 255, 255, 255}; // White
-            case ImGuiToastType::Success:
-                return {0, 255, 0, 255}; // Green
-            case ImGuiToastType::Warning:
-                return {255, 255, 0, 255}; // Yellow
-            case ImGuiToastType::Error:
-                return {255, 0, 0, 255}; // Error
-            case ImGuiToastType::Info:
-                return {0, 157, 255, 255}; // Blue
-            default:
-                return {255, 255, 255, 255}; // White
-        }
-    }
-
-    /**
-     * @brief Get the icon of the toast notification based on its type.
-     *
-     * @return const char* The icon of the toast notification.
-     */
-    inline const char* getIcon()
-    {
-        switch (this->type)
-        {
-            case ImGuiToastType::None:
-                return nullptr;
-            case ImGuiToastType::Success:
-                return ICON_FA_CIRCLE_CHECK; // Font Awesome 6
-            case ImGuiToastType::Warning:
-                return ICON_FA_TRIANGLE_EXCLAMATION; // Font Awesome 6
-            case ImGuiToastType::Error:
-                return ICON_FA_CIRCLE_EXCLAMATION; // Font Awesome 6
-            case ImGuiToastType::Info:
-                return ICON_FA_CIRCLE_INFO; // Font Awesome 6
-            default:
-                return nullptr;
-        }
-    }
-
-    /**
-     * @brief Get the content of the toast notification.
-     *
-     * @return char* The content of the toast notification.
-     */
-    inline char* getContent()
-    {
-        return this->content;
-    };
-
-    /**
-     * @brief Get the elapsed time in milliseconds since the creation of the object.
-     *
-     * @return int64_t The elapsed time in milliseconds.
-     * @throws An exception with the message "Unsupported platform" if the platform is not supported.
-     */
-    inline std::chrono::nanoseconds getElapsedTime()
-    {
-        return std::chrono::system_clock::now() - this->creationTime;
-    }
-
-    /**
-     * @brief Get the current phase of the toast notification based on the elapsed time since its creation.
-     *
-     * @return ImGuiToastPhase The current phase of the toast notification.
-     *         - ImGuiToastPhase::FadeIn: The notification is fading in.
-     *         - ImGuiToastPhase::Wait: The notification is waiting to be dismissed.
-     *         - ImGuiToastPhase::FadeOut: The notification is fading out.
-     *         - ImGuiToastPhase::Expired: The notification has expired and should be removed.
-     */
-    inline ImGuiToastPhase getPhase()
-    {
-        const int64_t elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(getElapsedTime()).count();
-
-        if (elapsed > NOTIFY_FADE_IN_OUT_TIME + this->dismissTime + NOTIFY_FADE_IN_OUT_TIME)
-        {
-            return ImGuiToastPhase::Expired;
-        } else
-        if (elapsed > NOTIFY_FADE_IN_OUT_TIME + this->dismissTime)
-        {
-            return ImGuiToastPhase::FadeOut;
-        } else
-        if (elapsed > NOTIFY_FADE_IN_OUT_TIME)
-        {
-            return ImGuiToastPhase::Wait;
-        } else
-        {
-            return ImGuiToastPhase::FadeIn;
-        }
-    }
-
-    /**
-     * Returns the percentage of fade for the notification.
-     * @return The percentage of fade for the notification.
-     */
-    inline float getFadePercent()
-    {
-        const ImGuiToastPhase phase = getPhase();
-        const int64_t elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(getElapsedTime()).count();
-
-        if (phase == ImGuiToastPhase::FadeIn)
-        {
-            return ((float)elapsed / (float)NOTIFY_FADE_IN_OUT_TIME) * NOTIFY_OPACITY;
-        } else
-        if (phase == ImGuiToastPhase::FadeOut)
-        {
-            return (1.f - (((float)elapsed - (float)NOTIFY_FADE_IN_OUT_TIME - (float)this->dismissTime) / (float)NOTIFY_FADE_IN_OUT_TIME)) * NOTIFY_OPACITY;
-        }
-
-        return 1.f * NOTIFY_OPACITY;
-    }
-
-    /**
-     * @return ImGui window flags for the notification.
-    */
-    inline ImGuiWindowFlags getWindowFlags()
-    {
-        return this->flags;
-    }
-
-    /**
-     * @return The function, which is executed on the button click in the notification.
-    */
-    inline std::function<void()> getOnButtonPress()
-    {
-        return this->onButtonPress;
-    }
-
-    /**
-     * @return The label on the button in notification.
-    */
-    inline const char* getButtonLabel()
-    {
-        return this->buttonLabel;
-    }
-
-public:
-    // Constructors
-
-    /**
-     * @brief Creates a new ImGuiToast object with the specified type and dismiss time.
-     *
-     * @param type The type of the toast.
-     * @param dismissTime The time in milliseconds after which the toast should be dismissed. Default is NOTIFY_DEFAULT_DISMISS.
-     */
-    ImGuiToast(ImGuiToastType type, int dismissTime = NOTIFY_DEFAULT_DISMISS)
-    {
-        IM_ASSERT(type < ImGuiToastType::COUNT);
-
-        this->type = type;
-        this->dismissTime = dismissTime;
-
-        this->creationTime = std::chrono::system_clock::now();
-
-        memset(this->title, 0, sizeof(this->title));
-        memset(this->content, 0, sizeof(this->content));
-    }
-
-    /**
-     * @brief Constructor for creating an ImGuiToast object with a specified type and message format.
-     *
-     * @param type The type of the toast message.
-     * @param format The format string for the message.
-     * @param ... The variable arguments to be formatted according to the format string.
-     */
-    ImGuiToast(ImGuiToastType type, const char* format, ...) : ImGuiToast(type)
-    {
-        NOTIFY_FORMAT(this->setContent, format);
-    }
-
-    /**
-     * @brief Constructor for creating a new ImGuiToast object with a specified type, dismiss time, and content format.
-     *
-     * @param type The type of the toast message.
-     * @param dismissTime The time in milliseconds before the toast message is dismissed.
-     * @param format The format string for the content of the toast message.
-     * @param ... The variable arguments to be formatted according to the format string.
-     */
-    ImGuiToast(ImGuiToastType type, int dismissTime, const char* format, ...) : ImGuiToast(type, dismissTime)
-    {
-        NOTIFY_FORMAT(this->setContent, format);
-    }
-
-    /**
-     * @brief Constructor for creating a new ImGuiToast object with a specified type, dismiss time, title format, content format and a button.
-     *
-     * @param type The type of the toast message.
-     * @param dismissTime The time in milliseconds before the toast message is dismissed.
-     * @param buttonLabel The label for the button.
-     * @param onButtonPress The lambda function to be executed when the button is pressed.
-     * @param format The format string for the content of the toast message.
-     * @param ... The variable arguments to be formatted according to the format string.
-     */
-    ImGuiToast(ImGuiToastType type, int dismissTime, const char* buttonLabel, const std::function<void()>& onButtonPress, const char* format, ...) : ImGuiToast(type, dismissTime)
-    {
-        NOTIFY_FORMAT(this->setContent, format);
-
-        this->onButtonPress = onButtonPress;
-        this->setButtonLabel(buttonLabel);
-    }
-};
-
-namespace ImGui
-{
-    inline std::vector<ImGuiToast> notifications;
-
-    /**
-     * Inserts a new notification into the notification queue.
-     * @param toast The notification to be inserted.
-     */
-    inline void InsertNotification(const ImGuiToast& toast)
-    {
-        notifications.push_back(toast);
-    }
-
-    /**
-     * @brief Removes a notification from the list of notifications.
-     *
-     * @param index The index of the notification to remove.
-     */
-    inline void RemoveNotification(int index)
-    {
-        notifications.erase(notifications.begin() + index);
-    }
-
-
-    /**
-     * Renders all notifications in the notifications vector.
-     * Each notification is rendered as a toast window with a title, content and an optional icon.
-     * If a notification is expired, it is removed from the vector.
-     */
-    inline void RenderNotifications()
-    {
-        const ImVec2 mainWindowSize = GetMainViewport()->Size;
-
-        float height = 0.f;
-
-        for (size_t i = 0; i < notifications.size(); i++)
-        {
-            ImGuiToast* currentToast = &notifications[i];
-
-            // Remove toast if expired
-            if (currentToast->getPhase() == ImGuiToastPhase::Expired)
-            {
-                RemoveNotification(i);
-                continue;
-            }
-
-            // Get icon, title and other data
-            const char* icon = currentToast->getIcon();
-            const char* title = currentToast->getTitle();
-            const char* content = currentToast->getContent();
-            const char* defaultTitle = currentToast->getDefaultTitle();
-            const float opacity = currentToast->getFadePercent(); // Get opacity based of the current phase
-
-            // Window rendering
-            ImVec4 textColor = currentToast->getColor();
-            textColor.w = opacity;
-
-            // Generate new unique name for this toast
-            char windowName[50];
-#ifdef _WIN32
-            sprintf_s(windowName, "##TOAST%d", (int)i);
-#elif defined(__linux__)
-            sprintf(windowName, "##TOAST%d", (int)i);
-#else
-            throw "Unsupported platform";
-#endif
-
-            //PushStyleColor(ImGuiCol_Text, textColor);
-            SetNextWindowBgAlpha(opacity);
-
-            // Set notification window position to bottom right corner of the main window, considering the main window size and location in relation to the display
-            ImVec2 mainWindowPos = GetMainViewport()->Pos;
-            SetNextWindowPos(ImVec2(mainWindowPos.x + mainWindowSize.x - NOTIFY_PADDING_X, mainWindowPos.y + mainWindowSize.y - NOTIFY_PADDING_Y - height), ImGuiCond_Always, ImVec2(1.0f, 1.0f));
-
-            // Set notification window flags
-            if (!NOTIFY_USE_DISMISS_BUTTON && currentToast->getOnButtonPress() == nullptr)
-            {
-                currentToast->setWindowFlags(NOTIFY_DEFAULT_TOAST_FLAGS | ImGuiWindowFlags_NoInputs);
-            }
-
-            Begin(windowName, nullptr, currentToast->getWindowFlags());
-
-            // Render over all other windows
-            BringWindowToDisplayFront(GetCurrentWindow());
-
-            // Here we render the toast content
-            {
-                PushTextWrapPos(mainWindowSize.x / 3.f); // We want to support multi-line text, this will wrap the text after 1/3 of the screen width
-
-                bool wasTitleRendered = false;
-
-                // If an icon is set
-                if (!NOTIFY_NULL_OR_EMPTY(icon))
-                {
-                    //Text(icon); // Render icon text
-                    TextColored(textColor, "%s", icon);
-                    wasTitleRendered = true;
-                }
-
-                // If a title is set
-                if (!NOTIFY_NULL_OR_EMPTY(title))
-                {
-                    // If a title and an icon is set, we want to render on same line
-                    if (!NOTIFY_NULL_OR_EMPTY(icon))
-                        SameLine();
-
-                    Text("%s", title); // Render title text
-                    wasTitleRendered = true;
-                } else
-                if (!NOTIFY_NULL_OR_EMPTY(defaultTitle))
-                {
-                    if (!NOTIFY_NULL_OR_EMPTY(icon))
-                        SameLine();
-
-                    Text("%s", defaultTitle); // Render default title text (ImGuiToastType_Success -> "Success", etc...)
-                    wasTitleRendered = true;
-                }
-
-                // If a dismiss button is enabled
-                if (NOTIFY_USE_DISMISS_BUTTON)
-                {
-                    // If a title or content is set, we want to render the button on the same line
-                    if (wasTitleRendered || !NOTIFY_NULL_OR_EMPTY(content))
-                    {
-                        SameLine();
-                    }
-
-                    // Render the dismiss button on the top right corner
-                    // NEEDS TO BE REWORKED
-                    float scale = 0.8f;
-
-                    if (CalcTextSize(content).x > GetWindowContentRegionMax().x)
-                    {
-                        scale = 0.95f;
-                    }
-
-                    SetCursorPosX(GetCursorPosX() + (GetWindowSize().x - GetCursorPosX()) * scale);
-
-                    // If the button is pressed, we want to remove the notification
-                    if (Button(ICON_FA_XMARK))
-                    {
-                        RemoveNotification(i);
-                    }
-                }
-
-                // In case ANYTHING was rendered in the top, we want to add a small padding so the text (or icon) looks centered vertically
-                if (wasTitleRendered && !NOTIFY_NULL_OR_EMPTY(content))
-                {
-                    SetCursorPosY(GetCursorPosY() + 5.f); // Must be a better way to do this!!!!
-                }
-
-                // If a content is set
-                if (!NOTIFY_NULL_OR_EMPTY(content))
-                {
-                    if (wasTitleRendered)
-                    {
-#if NOTIFY_USE_SEPARATOR
-                        Separator();
-#endif
-                    }
-
-                    Text("%s", content); // Render content text
-                }
-
-                // If a button is set
-                if (currentToast->getOnButtonPress() != nullptr)
-                {
-                    // If the button is pressed, we want to execute the lambda function
-                    if (Button(currentToast->getButtonLabel()))
-                    {
-                        currentToast->getOnButtonPress()();
-                    }
-                }
-
-                PopTextWrapPos();
-            }
-
-            // Save height for next toasts
-            height += GetWindowHeight() + NOTIFY_PADDING_MESSAGE_Y;
-
-            // End
-            End();
-        }
-    }
-}
-
-#endif
diff --git a/Dependencies/spdlog/.clang-format b/Dependencies/spdlog/.clang-format
deleted file mode 100644
index c8c345f6..00000000
--- a/Dependencies/spdlog/.clang-format
+++ /dev/null
@@ -1,19 +0,0 @@
----
-Language:        Cpp
-BasedOnStyle:  Google
-AccessModifierOffset: -4
-Standard:        c++17
-IndentWidth:     4
-TabWidth:        4
-UseTab:          Never
-ColumnLimit:     100
-AlignAfterOpenBracket: Align
-BinPackParameters: false
-AlignEscapedNewlines: Left
-AlwaysBreakTemplateDeclarations: Yes
-PackConstructorInitializers: Never
-BreakConstructorInitializersBeforeComma: false
-IndentPPDirectives: BeforeHash
-SortIncludes:    Never
-...
-
diff --git a/Dependencies/spdlog/.clang-tidy b/Dependencies/spdlog/.clang-tidy
deleted file mode 100644
index 34239d6b..00000000
--- a/Dependencies/spdlog/.clang-tidy
+++ /dev/null
@@ -1,54 +0,0 @@
-Checks: 'cppcoreguidelines-*,
-performance-*,
-modernize-*,
-google-*,
-misc-*
-cert-*,
-readability-*,
-clang-analyzer-*,
--performance-unnecessary-value-param,
--modernize-use-trailing-return-type,
--google-runtime-references,
--misc-non-private-member-variables-in-classes,
--readability-braces-around-statements,
--google-readability-braces-around-statements,
--cppcoreguidelines-avoid-magic-numbers,
--readability-magic-numbers,
--readability-magic-numbers,
--cppcoreguidelines-pro-type-vararg,
--cppcoreguidelines-pro-bounds-pointer-arithmetic,
--cppcoreguidelines-avoid-c-arrays,
--modernize-avoid-c-arrays,
--cppcoreguidelines-pro-bounds-array-to-pointer-decay,
--readability-named-parameter,
--cert-env33-c
-'
-
-
-WarningsAsErrors: ''
-HeaderFilterRegex: '*spdlog/[^f].*'
-AnalyzeTemporaryDtors: false
-FormatStyle:     none
-
-CheckOptions:    
-  - key:             google-readability-braces-around-statements.ShortStatementLines
-    value:           '1'
-  - key:             google-readability-function-size.StatementThreshold
-    value:           '800'
-  - key:             google-readability-namespace-comments.ShortNamespaceLines
-    value:           '10'
-  - key:             google-readability-namespace-comments.SpacesBeforeComments
-    value:           '2'
-  - key:             modernize-loop-convert.MaxCopySize
-    value:           '16'
-  - key:             modernize-loop-convert.MinConfidence
-    value:           reasonable
-  - key:             modernize-loop-convert.NamingStyle
-    value:           CamelCase
-  - key:             modernize-pass-by-value.IncludeStyle
-    value:           llvm
-  - key:             modernize-replace-auto-ptr.IncludeStyle
-    value:           llvm
-  - key:             modernize-use-nullptr.NullMacros
-    value:           'NULL'
-
diff --git a/Dependencies/spdlog/.git-blame-ignore-revs b/Dependencies/spdlog/.git-blame-ignore-revs
deleted file mode 100644
index 47b8fed1..00000000
--- a/Dependencies/spdlog/.git-blame-ignore-revs
+++ /dev/null
@@ -1,6 +0,0 @@
-# clang-format
-1a0bfc7a89f2d58e22605a4dc7e18a9a555b65aa
-95c226e9c92928e20ccdac0d060e7241859e282b
-9d52261185b5f2c454c381d626ec5c84d7b195f4
-4b2a8219d5d1b40062d030441adde7d1fb0d4f84
-0a53eafe18d983c7c8ba4cadd02d0cc7f7308f28
diff --git a/Dependencies/spdlog/.gitattributes b/Dependencies/spdlog/.gitattributes
deleted file mode 100644
index fe505b27..00000000
--- a/Dependencies/spdlog/.gitattributes
+++ /dev/null
@@ -1 +0,0 @@
-* text=false
diff --git a/Dependencies/spdlog/.github/workflows/ci.yml b/Dependencies/spdlog/.github/workflows/ci.yml
deleted file mode 100644
index abd96b3e..00000000
--- a/Dependencies/spdlog/.github/workflows/ci.yml
+++ /dev/null
@@ -1,78 +0,0 @@
-name: ci
-
-on: [push, pull_request]
-
-jobs:
-  build_linux:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        shell: bash
-    strategy:
-      fail-fast: false
-      matrix:
-        config:
-          - { compiler: gcc, version: 7, build_type: Release, cppstd: 11 }
-          - { compiler: gcc, version: 9, build_type: Release, cppstd: 17 }
-          - { compiler: gcc, version: 11, build_type: Debug, cppstd: 20 }
-          - { compiler: gcc, version: 12, build_type: Release, cppstd: 20 }
-          - { compiler: clang, version: 12, build_type: Debug, cppstd: 17, asan: OFF }
-          - { compiler: clang, version: 15, build_type: Release, cppstd: 20, asan: OFF }
-    container:
-      image: ${{ matrix.config.compiler == 'clang' && 'teeks99/clang-ubuntu' || matrix.config.compiler }}:${{ matrix.config.version }}
-    name: "${{ matrix.config.compiler}} ${{ matrix.config.version }} (C++${{ matrix.config.cppstd }}, ${{ matrix.config.build_type }})"
-    steps:
-      - uses: actions/checkout@main
-      - name: Setup
-        run: |
-          apt-get update && apt-get install -y curl git pkg-config libsystemd-dev
-          CMAKE_VERSION="3.24.2"
-          curl -sSL https://github.com/Kitware/CMake/releases/download/v${CMAKE_VERSION}/cmake-${CMAKE_VERSION}-linux-x86_64.sh -o install-cmake.sh
-          chmod +x install-cmake.sh
-          ./install-cmake.sh --prefix=/usr/local --skip-license
-      - name: Setup Compiler
-        if: matrix.config.compiler == 'clang'
-        run: |
-          if [[ "${{ matrix.config.version }}" -ge 4 ]]; then
-            scripts/ci_setup_clang.sh "${{ matrix.config.version }}"
-            echo "CXXFLAGS=-stdlib=libc++" >> $GITHUB_ENV
-          fi
-          echo "CC=clang-${{ matrix.config.version }}" >> $GITHUB_ENV
-          echo "CXX=clang++-${{ matrix.config.version }}" >> $GITHUB_ENV
-      - name: Build
-        run: |
-          mkdir -p build && cd build
-          cmake .. \
-            -DCMAKE_BUILD_TYPE=${{ matrix.config.build_type }} \
-            -DCMAKE_CXX_STANDARD=${{ matrix.config.cppstd }} \
-            -DSPDLOG_BUILD_EXAMPLE=${{ matrix.config.examples || 'ON' }} \
-            -DSPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.examples || 'ON' }} \
-            -DSPDLOG_BUILD_WARNINGS=ON \
-            -DSPDLOG_BUILD_BENCH=OFF \
-            -DSPDLOG_BUILD_TESTS=ON \
-            -DSPDLOG_BUILD_TESTS_HO=OFF \
-            -DSPDLOG_SANITIZE_ADDRESS=${{ matrix.config.asan || 'ON' }}
-          make -j2
-          ctest -j2 --output-on-failure
-
-  build_osx:
-    runs-on: macOS-latest
-    name: "OS X Clang (C++11, Release)"
-    steps:
-      - uses: actions/checkout@main
-      - name: Build
-        run: |
-          mkdir -p build && cd build
-          cmake .. \
-            -DCMAKE_BUILD_TYPE=Release \
-            -DCMAKE_CXX_STANDARD=11 \
-            -DSPDLOG_BUILD_EXAMPLE=ON \
-            -DSPDLOG_BUILD_EXAMPLE_HO=ON \
-            -DSPDLOG_BUILD_WARNINGS=ON \
-            -DSPDLOG_BUILD_BENCH=OFF \
-            -DSPDLOG_BUILD_TESTS=ON \
-            -DSPDLOG_BUILD_TESTS_HO=OFF \
-            -DSPDLOG_SANITIZE_ADDRESS=OFF
-          make -j2
-          ctest -j2 --output-on-failure
-
diff --git a/Dependencies/spdlog/.gitignore b/Dependencies/spdlog/.gitignore
deleted file mode 100644
index e31f5eb6..00000000
--- a/Dependencies/spdlog/.gitignore
+++ /dev/null
@@ -1,95 +0,0 @@
-# Auto generated files
-[Dd]ebug/
-[Rr]elease/
-build/*
-*.slo
-*.lo
-*.o
-*.obj
-*.suo
-*.tlog
-*.ilk
-*.log
-*.pdb
-*.idb
-*.iobj
-*.ipdb
-*.opensdf
-*.sdf
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app
-
-# Codelite
-.codelite
-
-# KDevelop
-*.kdev4
-
-# .orig files
-*.orig
-
-# example  files
-example/*
-!example/example.cpp
-!example/bench.cpp
-!example/utils.h
-!example/Makefile*
-!example/example.sln
-!example/example.vcxproj
-!example/CMakeLists.txt
-!example/meson.build
-!example/multisink.cpp
-!example/jni
-
-# generated files
-generated
-version.rc
-
-# Cmake
-CMakeCache.txt
-CMakeFiles
-CMakeScripts
-Makefile
-cmake_install.cmake
-install_manifest.txt
-/tests/tests.VC.VC.opendb
-/tests/tests.VC.db
-/tests/tests
-/tests/logs/*
-spdlogConfig.cmake
-spdlogConfigVersion.cmake
-compile_commands.json
-
-# idea
-.idea/
-.cache/
-.vscode/
-cmake-build-*/
-*.db
-*.ipch
-*.filters
-*.db-wal
-*.opendb
-*.db-shm
-*.vcxproj
-*.tcl
-*.user
-*.sln
-
-# macos
-*.DS_store
-*.xcodeproj/
diff --git a/Dependencies/spdlog/CMakeLists.txt b/Dependencies/spdlog/CMakeLists.txt
deleted file mode 100644
index b2f6b61c..00000000
--- a/Dependencies/spdlog/CMakeLists.txt
+++ /dev/null
@@ -1,359 +0,0 @@
-# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-cmake_minimum_required(VERSION 3.11)
-
-# ---------------------------------------------------------------------------------------
-# Start spdlog project
-# ---------------------------------------------------------------------------------------
-include(cmake/utils.cmake)
-include(cmake/ide.cmake)
-
-spdlog_extract_version()
-
-project(spdlog VERSION ${SPDLOG_VERSION} LANGUAGES CXX)
-message(STATUS "Build spdlog: ${SPDLOG_VERSION}")
-
-include(GNUInstallDirs)
-
-# ---------------------------------------------------------------------------------------
-# Set default build to release
-# ---------------------------------------------------------------------------------------
-if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
-    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose Release or Debug" FORCE)
-endif()
-
-# ---------------------------------------------------------------------------------------
-# Compiler config
-# ---------------------------------------------------------------------------------------
-if(SPDLOG_USE_STD_FORMAT)
-    set(CMAKE_CXX_STANDARD 20)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-elseif(NOT CMAKE_CXX_STANDARD)
-    set(CMAKE_CXX_STANDARD 11)
-    set(CMAKE_CXX_STANDARD_REQUIRED ON)
-endif()
-
-# make sure __cplusplus is defined when using msvc and enable parallel build
-if(MSVC)
-    string(APPEND CMAKE_CXX_FLAGS " /Zc:__cplusplus /MP")
-endif()
-
-set(CMAKE_CXX_EXTENSIONS OFF)
-
-if(CMAKE_SYSTEM_NAME MATCHES "CYGWIN" OR CMAKE_SYSTEM_NAME MATCHES "MSYS")
-    set(CMAKE_CXX_EXTENSIONS ON)
-endif()
-
-# ---------------------------------------------------------------------------------------
-# Set SPDLOG_MASTER_PROJECT to ON if we are building spdlog
-# ---------------------------------------------------------------------------------------
-# Check if spdlog is being used directly or via add_subdirectory, but allow overriding
-if(NOT DEFINED SPDLOG_MASTER_PROJECT)
-    if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-        set(SPDLOG_MASTER_PROJECT ON)
-    else()
-        set(SPDLOG_MASTER_PROJECT OFF)
-    endif()
-endif()
-
-option(SPDLOG_BUILD_ALL "Build all artifacts" OFF)
-
-# build shared option
-option(SPDLOG_BUILD_SHARED "Build shared library" OFF)
-
-# precompiled headers option
-option(SPDLOG_ENABLE_PCH "Build static or shared library using precompiled header to speed up compilation time" OFF)
-
-# build position independent code
-option(SPDLOG_BUILD_PIC "Build position independent code (-fPIC)" OFF)
-
-# example options
-option(SPDLOG_BUILD_EXAMPLE "Build example" ${SPDLOG_MASTER_PROJECT})
-option(SPDLOG_BUILD_EXAMPLE_HO "Build header only example" OFF)
-
-# testing options
-option(SPDLOG_BUILD_TESTS "Build tests" OFF)
-option(SPDLOG_BUILD_TESTS_HO "Build tests using the header only version" OFF)
-
-# bench options
-option(SPDLOG_BUILD_BENCH "Build benchmarks (Requires https://github.com/google/benchmark.git to be installed)" OFF)
-
-# sanitizer options
-option(SPDLOG_SANITIZE_ADDRESS "Enable address sanitizer in tests" OFF)
-
-# warning options
-option(SPDLOG_BUILD_WARNINGS "Enable compiler warnings" OFF)
-
-# install options
-option(SPDLOG_SYSTEM_INCLUDES "Include as system headers (skip for clang-tidy)." OFF)
-option(SPDLOG_INSTALL "Generate the install target" ${SPDLOG_MASTER_PROJECT})
-option(SPDLOG_USE_STD_FORMAT "Use std::format instead of fmt library." OFF)
-option(SPDLOG_FMT_EXTERNAL "Use external fmt library instead of bundled" OFF)
-option(SPDLOG_FMT_EXTERNAL_HO "Use external fmt header-only library instead of bundled" OFF)
-option(SPDLOG_NO_EXCEPTIONS "Compile with -fno-exceptions. Call abort() on any spdlog exceptions" OFF)
-
-if(SPDLOG_FMT_EXTERNAL AND SPDLOG_FMT_EXTERNAL_HO)
-    message(FATAL_ERROR "SPDLOG_FMT_EXTERNAL and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
-endif()
-
-if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL_HO)
-    message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL_HO are mutually exclusive")
-endif()
-
-if(SPDLOG_USE_STD_FORMAT AND SPDLOG_FMT_EXTERNAL)
-    message(FATAL_ERROR "SPDLOG_USE_STD_FORMAT and SPDLOG_FMT_EXTERNAL are mutually exclusive")
-endif()
-
-# misc tweakme options
-if(WIN32)
-    option(SPDLOG_WCHAR_SUPPORT "Support wchar api" OFF)
-    option(SPDLOG_WCHAR_FILENAMES "Support wchar filenames" OFF)
-else()
-    set(SPDLOG_WCHAR_SUPPORT OFF CACHE BOOL "non supported option" FORCE)
-    set(SPDLOG_WCHAR_FILENAMES OFF CACHE BOOL "non supported option" FORCE)
-endif()
-
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-    option(SPDLOG_CLOCK_COARSE "Use CLOCK_REALTIME_COARSE instead of the regular clock," OFF)
-else()
-    set(SPDLOG_CLOCK_COARSE OFF CACHE BOOL "non supported option" FORCE)
-endif()
-
-option(SPDLOG_PREVENT_CHILD_FD "Prevent from child processes to inherit log file descriptors" OFF)
-option(SPDLOG_NO_THREAD_ID "prevent spdlog from querying the thread id on each log call if thread id is not needed" OFF)
-option(SPDLOG_NO_TLS "prevent spdlog from using thread local storage" OFF)
-option(
-    SPDLOG_NO_ATOMIC_LEVELS
-    "prevent spdlog from using of std::atomic log levels (use only if your code never modifies log levels concurrently"
-    OFF)
-option(SPDLOG_DISABLE_DEFAULT_LOGGER "Disable default logger creation" OFF)
-
-# clang-tidy
-option(SPDLOG_TIDY "run clang-tidy" OFF)
-
-if(SPDLOG_TIDY)
-    set(CMAKE_CXX_CLANG_TIDY "clang-tidy")
-    set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-    message(STATUS "Enabled clang-tidy")
-endif()
-
-if(SPDLOG_BUILD_PIC)
-    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-endif()
-
-find_package(Threads REQUIRED)
-message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})
-# ---------------------------------------------------------------------------------------
-# Static/Shared library
-# ---------------------------------------------------------------------------------------
-set(SPDLOG_SRCS src/spdlog.cpp src/stdout_sinks.cpp src/color_sinks.cpp src/file_sinks.cpp src/async.cpp src/cfg.cpp)
-
-if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-    list(APPEND SPDLOG_SRCS src/bundled_fmtlib_format.cpp)
-endif()
-
-if(SPDLOG_BUILD_SHARED OR BUILD_SHARED_LIBS)
-    if(WIN32)
-        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/version.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc @ONLY)
-        list(APPEND SPDLOG_SRCS ${CMAKE_CURRENT_BINARY_DIR}/version.rc)
-    endif()
-    add_library(spdlog SHARED ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
-    target_compile_definitions(spdlog PUBLIC SPDLOG_SHARED_LIB)
-    if(MSVC)
-        target_compile_options(spdlog PUBLIC $<$<AND:$<CXX_COMPILER_ID:MSVC>,$<NOT:$<COMPILE_LANGUAGE:CUDA>>>:/wd4251
-                                             /wd4275>)
-    endif()
-    if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-        target_compile_definitions(spdlog PRIVATE FMT_EXPORT PUBLIC FMT_SHARED)
-    endif()
-else()
-    add_library(spdlog STATIC ${SPDLOG_SRCS} ${SPDLOG_ALL_HEADERS})
-endif()
-
-add_library(spdlog::spdlog ALIAS spdlog)
-
-set(SPDLOG_INCLUDES_LEVEL "")
-if(SPDLOG_SYSTEM_INCLUDES)
-    set(SPDLOG_INCLUDES_LEVEL "SYSTEM")
-endif()
-
-target_compile_definitions(spdlog PUBLIC SPDLOG_COMPILED_LIB)
-target_include_directories(spdlog ${SPDLOG_INCLUDES_LEVEL} PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
-                                                                  "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-target_link_libraries(spdlog PUBLIC Threads::Threads)
-spdlog_enable_warnings(spdlog)
-
-set_target_properties(spdlog PROPERTIES VERSION ${SPDLOG_VERSION} SOVERSION
-                                                                  ${SPDLOG_VERSION_MAJOR}.${SPDLOG_VERSION_MINOR})
-set_target_properties(spdlog PROPERTIES DEBUG_POSTFIX d)
-
-if(COMMAND target_precompile_headers AND SPDLOG_ENABLE_PCH)
-    configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pch.h.in ${PROJECT_BINARY_DIR}/spdlog_pch.h @ONLY)
-    target_precompile_headers(spdlog PRIVATE ${PROJECT_BINARY_DIR}/spdlog_pch.h)
-endif()
-
-# ---------------------------------------------------------------------------------------
-# Header only version
-# ---------------------------------------------------------------------------------------
-add_library(spdlog_header_only INTERFACE)
-add_library(spdlog::spdlog_header_only ALIAS spdlog_header_only)
-
-target_include_directories(
-    spdlog_header_only ${SPDLOG_INCLUDES_LEVEL} INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
-                                                          "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-target_link_libraries(spdlog_header_only INTERFACE Threads::Threads)
-
-# ---------------------------------------------------------------------------------------
-# Use fmt package if using external fmt
-# ---------------------------------------------------------------------------------------
-if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
-    if(NOT TARGET fmt::fmt)
-        find_package(fmt CONFIG REQUIRED)
-    endif()
-    target_compile_definitions(spdlog PUBLIC SPDLOG_FMT_EXTERNAL)
-    target_compile_definitions(spdlog_header_only INTERFACE SPDLOG_FMT_EXTERNAL)
-
-    # use external fmt-header-nly
-    if(SPDLOG_FMT_EXTERNAL_HO)
-        target_link_libraries(spdlog PUBLIC fmt::fmt-header-only)
-        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt-header-only)
-    else() # use external compile fmt
-        target_link_libraries(spdlog PUBLIC fmt::fmt)
-        target_link_libraries(spdlog_header_only INTERFACE fmt::fmt)
-    endif()
-
-    set(PKG_CONFIG_REQUIRES fmt) # add dependency to pkg-config
-endif()
-
-# ---------------------------------------------------------------------------------------
-# Add required libraries for Android CMake build
-# ---------------------------------------------------------------------------------------
-if(ANDROID)
-    target_link_libraries(spdlog PUBLIC log)
-    target_link_libraries(spdlog_header_only INTERFACE log)
-endif()
-
-# ---------------------------------------------------------------------------------------
-# Misc definitions according to tweak options
-# ---------------------------------------------------------------------------------------
-set(SPDLOG_WCHAR_TO_UTF8_SUPPORT ${SPDLOG_WCHAR_SUPPORT})
-foreach(
-    SPDLOG_OPTION
-    SPDLOG_WCHAR_TO_UTF8_SUPPORT
-    SPDLOG_WCHAR_FILENAMES
-    SPDLOG_NO_EXCEPTIONS
-    SPDLOG_CLOCK_COARSE
-    SPDLOG_PREVENT_CHILD_FD
-    SPDLOG_NO_THREAD_ID
-    SPDLOG_NO_TLS
-    SPDLOG_NO_ATOMIC_LEVELS
-    SPDLOG_DISABLE_DEFAULT_LOGGER
-    SPDLOG_USE_STD_FORMAT)
-    if(${SPDLOG_OPTION})
-        target_compile_definitions(spdlog PUBLIC ${SPDLOG_OPTION})
-        target_compile_definitions(spdlog_header_only INTERFACE ${SPDLOG_OPTION})
-    endif()
-endforeach()
-
-# ---------------------------------------------------------------------------------------
-# If exceptions are disabled, disable them in the bundled fmt as well
-# ---------------------------------------------------------------------------------------
-if(SPDLOG_NO_EXCEPTIONS)
-    if(NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-        target_compile_definitions(spdlog PUBLIC FMT_EXCEPTIONS=0)
-    endif()
-    if(NOT MSVC)
-        target_compile_options(spdlog PRIVATE -fno-exceptions)
-    else()
-        target_compile_options(spdlog PRIVATE /EHsc)
-    endif()
-endif()
-# ---------------------------------------------------------------------------------------
-# Build binaries
-# ---------------------------------------------------------------------------------------
-if(SPDLOG_BUILD_EXAMPLE OR SPDLOG_BUILD_EXAMPLE_HO OR SPDLOG_BUILD_ALL)
-    message(STATUS "Generating example(s)")
-    add_subdirectory(example)
-    spdlog_enable_warnings(example)
-    if(SPDLOG_BUILD_EXAMPLE_HO)
-        spdlog_enable_warnings(example_header_only)
-    endif()
-endif()
-
-if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
-    message(STATUS "Generating tests")
-    enable_testing()
-    add_subdirectory(tests)
-endif()
-
-if(SPDLOG_BUILD_BENCH OR SPDLOG_BUILD_ALL)
-    message(STATUS "Generating benchmarks")
-    add_subdirectory(bench)
-endif()
-
-# ---------------------------------------------------------------------------------------
-# Install
-# ---------------------------------------------------------------------------------------
-if(SPDLOG_INSTALL)
-    message(STATUS "Generating install")
-    set(project_config_in "${CMAKE_CURRENT_LIST_DIR}/cmake/spdlogConfig.cmake.in")
-    set(project_config_out "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfig.cmake")
-    set(config_targets_file "spdlogConfigTargets.cmake")
-    set(version_config_file "${CMAKE_CURRENT_BINARY_DIR}/spdlogConfigVersion.cmake")
-    set(export_dest_dir "${CMAKE_INSTALL_LIBDIR}/cmake/spdlog")
-    set(pkgconfig_install_dir "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-    set(pkg_config "${CMAKE_BINARY_DIR}/${PROJECT_NAME}.pc")
-
-    # ---------------------------------------------------------------------------------------
-    # Include files
-    # ---------------------------------------------------------------------------------------
-    install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}" PATTERN "fmt/bundled" EXCLUDE)
-    install(
-        TARGETS spdlog spdlog_header_only
-        EXPORT spdlog
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-
-    if(NOT SPDLOG_USE_STD_FORMAT AND NOT SPDLOG_FMT_EXTERNAL AND NOT SPDLOG_FMT_EXTERNAL_HO)
-        install(DIRECTORY include/${PROJECT_NAME}/fmt/bundled/
-                DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/fmt/bundled/")
-    endif()
-
-    # ---------------------------------------------------------------------------------------
-    # Install pkg-config file
-    # ---------------------------------------------------------------------------------------
-    if(IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
-        set(PKG_CONFIG_INCLUDEDIR "${CMAKE_INSTALL_INCLUDEDIR}")
-    else()
-        set(PKG_CONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
-    endif()
-    if(IS_ABSOLUTE "${CMAKE_INSTALL_LIBDIR}")
-        set(PKG_CONFIG_LIBDIR "${CMAKE_INSTALL_LIBDIR}")
-    else()
-        set(PKG_CONFIG_LIBDIR "\${exec_prefix}/${CMAKE_INSTALL_LIBDIR}")
-    endif()
-    get_target_property(PKG_CONFIG_DEFINES spdlog INTERFACE_COMPILE_DEFINITIONS)
-    string(REPLACE ";" " -D" PKG_CONFIG_DEFINES "${PKG_CONFIG_DEFINES}")
-    string(CONCAT PKG_CONFIG_DEFINES "-D" "${PKG_CONFIG_DEFINES}")
-    configure_file("cmake/${PROJECT_NAME}.pc.in" "${pkg_config}" @ONLY)
-    install(FILES "${pkg_config}" DESTINATION "${pkgconfig_install_dir}")
-
-    # ---------------------------------------------------------------------------------------
-    # Install CMake config files
-    # ---------------------------------------------------------------------------------------
-    export(TARGETS spdlog spdlog_header_only NAMESPACE spdlog::
-           FILE "${CMAKE_CURRENT_BINARY_DIR}/${config_targets_file}")
-    install(EXPORT spdlog DESTINATION ${export_dest_dir} NAMESPACE spdlog:: FILE ${config_targets_file})
-
-    include(CMakePackageConfigHelpers)
-    configure_package_config_file("${project_config_in}" "${project_config_out}" INSTALL_DESTINATION ${export_dest_dir})
-
-    write_basic_package_version_file("${version_config_file}" COMPATIBILITY SameMajorVersion)
-    install(FILES "${project_config_out}" "${version_config_file}" DESTINATION "${export_dest_dir}")
-
-    # ---------------------------------------------------------------------------------------
-    # Support creation of installable packages
-    # ---------------------------------------------------------------------------------------
-    include(cmake/spdlogCPack.cmake)
-endif()
diff --git a/Dependencies/spdlog/INSTALL b/Dependencies/spdlog/INSTALL
deleted file mode 100644
index 20a9b4c4..00000000
--- a/Dependencies/spdlog/INSTALL
+++ /dev/null
@@ -1,24 +0,0 @@
-Header only version:
-==================================================================
-Just copy the files to your build tree and use a C++11 compiler.
-Or use CMake:
-  add_executable(example_header_only example.cpp)
-  target_link_libraries(example_header_only spdlog::spdlog_header_only)
-
-
-Compiled library version:
-==================================================================
-CMake:
-  add_executable(example example.cpp)
-  target_link_libraries(example spdlog::spdlog)
-
-Or copy files src/*.cpp to your build tree and pass the -DSPDLOG_COMPILED_LIB to the compiler.
-
-Tested on:
-gcc 4.8.1 and above
-clang 3.5
-Visual Studio 2013
-
-
-
-
diff --git a/Dependencies/spdlog/LICENSE b/Dependencies/spdlog/LICENSE
index c15941bc..6546da0b 100644
--- a/Dependencies/spdlog/LICENSE
+++ b/Dependencies/spdlog/LICENSE
@@ -22,5 +22,5 @@ THE SOFTWARE.
 
 -- NOTE: Third party dependency used by this software --
 This software depends on the fmt lib (MIT License),
-and users must comply to its license: https://github.com/fmtlib/fmt/blob/master/LICENSE.rst
+and users must comply to its license: https://raw.githubusercontent.com/fmtlib/fmt/master/LICENSE
 
diff --git a/Dependencies/spdlog/README.md b/Dependencies/spdlog/README.md
deleted file mode 100644
index 6ec69bdc..00000000
--- a/Dependencies/spdlog/README.md
+++ /dev/null
@@ -1,500 +0,0 @@
-# spdlog
-
-Very fast, header-only/compiled, C++ logging library. [![ci](https://github.com/gabime/spdlog/actions/workflows/ci.yml/badge.svg)](https://github.com/gabime/spdlog/actions/workflows/ci.yml)&nbsp; [![Build status](https://ci.appveyor.com/api/projects/status/d2jnxclg20vd0o50?svg=true&branch=v1.x)](https://ci.appveyor.com/project/gabime/spdlog) [![Release](https://img.shields.io/github/release/gabime/spdlog.svg)](https://github.com/gabime/spdlog/releases/latest)
-
-## Install
-#### Header-only version
-Copy the include [folder](https://github.com/gabime/spdlog/tree/v1.x/include/spdlog) to your build tree and use a C++11 compiler.
-
-#### Compiled version (recommended - much faster compile times)
-```console
-$ git clone https://github.com/gabime/spdlog.git
-$ cd spdlog && mkdir build && cd build
-$ cmake .. && make -j
-```
-see example [CMakeLists.txt](https://github.com/gabime/spdlog/blob/v1.x/example/CMakeLists.txt) on how to use.
-
-## Platforms
-* Linux, FreeBSD, OpenBSD, Solaris, AIX
-* Windows (msvc 2013+, cygwin)
-* macOS (clang 3.5+)
-* Android
-
-## Package managers:
-* Debian: `sudo apt install libspdlog-dev`
-* Homebrew: `brew install spdlog`
-* MacPorts: `sudo port install spdlog`
-* FreeBSD:  `pkg install spdlog`
-* Fedora: `dnf install spdlog`
-* Gentoo: `emerge dev-libs/spdlog`
-* Arch Linux: `pacman -S spdlog`
-* openSUSE: `sudo zypper in spdlog-devel`
-* vcpkg: `vcpkg install spdlog`
-* conan: `spdlog/[>=1.4.1]`
-* conda: `conda install -c conda-forge spdlog`
-* build2: ```depends: spdlog ^1.8.2```
-
-
-## Features
-* Very fast (see [benchmarks](#benchmarks) below).
-* Headers only or compiled
-* Feature-rich formatting, using the excellent [fmt](https://github.com/fmtlib/fmt) library.
-* Asynchronous mode (optional)
-* [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
-* Multi/Single threaded loggers.
-* Various log targets:
-  * Rotating log files.
-  * Daily log files.
-  * Console logging (colors supported).
-  * syslog.
-  * Windows event log.
-  * Windows debugger (```OutputDebugString(..)```).
-  * Log to Qt widgets ([example](#log-to-qt-with-nice-colors)).
-  * Easily [extendable](https://github.com/gabime/spdlog/wiki/4.-Sinks#implementing-your-own-sink) with custom log targets.
-* Log filtering - log levels can be modified at runtime as well as compile time.
-* Support for loading log levels from argv or environment var.
-* [Backtrace](#backtrace-support) support - store debug messages in a ring buffer and display them later on demand.
-
-## Usage samples
-
-#### Basic usage
-```c++
-#include "spdlog/spdlog.h"
-
-int main() 
-{
-    spdlog::info("Welcome to spdlog!");
-    spdlog::error("Some error message with arg: {}", 1);
-    
-    spdlog::warn("Easy padding in numbers like {:08d}", 12);
-    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-    spdlog::info("Support for floats {:03.2f}", 1.23456);
-    spdlog::info("Positional args are {1} {0}..", "too", "supported");
-    spdlog::info("{:<30}", "left aligned");
-    
-    spdlog::set_level(spdlog::level::debug); // Set global log level to debug
-    spdlog::debug("This message should be displayed..");    
-    
-    // change log pattern
-    spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
-    
-    // Compile time log levels
-    // define SPDLOG_ACTIVE_LEVEL to desired level
-    SPDLOG_TRACE("Some trace message with param {}", 42);
-    SPDLOG_DEBUG("Some debug message");
-}
-
-```
----
-#### Create stdout/stderr logger object
-```c++
-#include "spdlog/spdlog.h"
-#include "spdlog/sinks/stdout_color_sinks.h"
-void stdout_example()
-{
-    // create a color multi-threaded logger
-    auto console = spdlog::stdout_color_mt("console");    
-    auto err_logger = spdlog::stderr_color_mt("stderr");    
-    spdlog::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name)");
-}
-```
-
----
-#### Basic file logger
-```c++
-#include "spdlog/sinks/basic_file_sink.h"
-void basic_logfile_example()
-{
-    try 
-    {
-        auto logger = spdlog::basic_logger_mt("basic_logger", "logs/basic-log.txt");
-    }
-    catch (const spdlog::spdlog_ex &ex)
-    {
-        std::cout << "Log init failed: " << ex.what() << std::endl;
-    }
-}
-```
----
-#### Rotating files
-```c++
-#include "spdlog/sinks/rotating_file_sink.h"
-void rotating_example()
-{
-    // Create a file rotating logger with 5 MB size max and 3 rotated files
-    auto max_size = 1048576 * 5;
-    auto max_files = 3;
-    auto logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", max_size, max_files);
-}
-```
-
----
-#### Daily files
-```c++
-
-#include "spdlog/sinks/daily_file_sink.h"
-void daily_example()
-{
-    // Create a daily logger - a new file is created every day at 2:30 am
-    auto logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
-}
-
-```
-
----
-#### Backtrace support
-```c++
-// Debug messages can be stored in a ring buffer instead of being logged immediately.
-// This is useful to display debug logs only when needed (e.g. when an error happens).
-// When needed, call dump_backtrace() to dump them to your log.
-
-spdlog::enable_backtrace(32); // Store the latest 32 messages in a buffer. 
-// or my_logger->enable_backtrace(32)..
-for(int i = 0; i < 100; i++)
-{
-  spdlog::debug("Backtrace message {}", i); // not logged yet..
-}
-// e.g. if some error happened:
-spdlog::dump_backtrace(); // log them now! show the last 32 messages
-// or my_logger->dump_backtrace(32)..
-```
-
----
-#### Periodic flush
-```c++
-// periodically flush all *registered* loggers every 3 seconds:
-// warning: only use if all your loggers are thread-safe ("_mt" loggers)
-spdlog::flush_every(std::chrono::seconds(3));
-
-```
-
----
-#### Stopwatch
-```c++
-// Stopwatch support for spdlog
-#include "spdlog/stopwatch.h"
-void stopwatch_example()
-{
-    spdlog::stopwatch sw;    
-    spdlog::debug("Elapsed {}", sw);
-    spdlog::debug("Elapsed {:.3}", sw);       
-}
-
-```
-
----
-#### Log binary data in hex
-```c++
-// many types of std::container<char> types can be used.
-// ranges are supported too.
-// format flags:
-// {:X} - print in uppercase.
-// {:s} - don't separate each byte with space.
-// {:p} - don't print the position on each line start.
-// {:n} - don't split the output into lines.
-// {:a} - show ASCII if :n is not set.
-
-#include "spdlog/fmt/bin_to_hex.h"
-
-void binary_example()
-{
-    auto console = spdlog::get("console");
-    std::array<char, 80> buf;
-    console->info("Binary example: {}", spdlog::to_hex(buf));
-    console->info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
-    // more examples:
-    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
-}
-
-```
-
----
-#### Logger with multi sinks - each with a different format and log level
-```c++
-
-// create a logger with 2 targets, with different log levels and formats.
-// The console will show only warnings or errors, while the file will log all.
-void multi_sink_example()
-{
-    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    console_sink->set_level(spdlog::level::warn);
-    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
-
-    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
-    file_sink->set_level(spdlog::level::trace);
-
-    spdlog::logger logger("multi_sink", {console_sink, file_sink});
-    logger.set_level(spdlog::level::debug);
-    logger.warn("this should appear in both console and file");
-    logger.info("this message should not appear in the console, only in the file");
-}
-```
-
----
-#### User-defined callbacks about log events
-```c++
-
-// create a logger with a lambda function callback, the callback will be called
-// each time something is logged to the logger
-void callback_example()
-{
-    auto callback_sink = std::make_shared<spdlog::sinks::callback_sink_mt>([](const spdlog::details::log_msg &msg) {
-         // for example you can be notified by sending an email to yourself
-    });
-    callback_sink->set_level(spdlog::level::err);
-
-    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    spdlog::logger logger("custom_callback_logger", {console_sink, callback_sink});
-
-    logger.info("some info log");
-    logger.error("critical issue"); // will notify you
-}
-```
-
----
-#### Asynchronous logging
-```c++
-#include "spdlog/async.h"
-#include "spdlog/sinks/basic_file_sink.h"
-void async_example()
-{
-    // default thread pool settings can be modified *before* creating the async logger:
-    // spdlog::init_thread_pool(8192, 1); // queue with 8k items and 1 backing thread.
-    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
-    // alternatively:
-    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");   
-}
-
-```
-
----
-#### Asynchronous logger with multi sinks
-```c++
-#include "spdlog/sinks/stdout_color_sinks.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-
-void multi_sink_example2()
-{
-    spdlog::init_thread_pool(8192, 1);
-    auto stdout_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt >();
-    auto rotating_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>("mylog.txt", 1024*1024*10, 3);
-    std::vector<spdlog::sink_ptr> sinks {stdout_sink, rotating_sink};
-    auto logger = std::make_shared<spdlog::async_logger>("loggername", sinks.begin(), sinks.end(), spdlog::thread_pool(), spdlog::async_overflow_policy::block);
-    spdlog::register_logger(logger);
-}
-```
- 
----
-#### User-defined types
-```c++
-template<>
-struct fmt::formatter<my_type> : fmt::formatter<std::string>
-{
-    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out())
-    {
-        return format_to(ctx.out(), "[my_type i={}]", my.i);
-    }
-};
-
-void user_defined_example()
-{
-    spdlog::info("user defined type: {}", my_type(14));
-}
-
-```
-
----
-#### User-defined flags in the log pattern
-```c++ 
-// Log patterns can contain custom flags.
-// the following example will add new flag '%*' - which will be bound to a <my_formatter_flag> instance.
-#include "spdlog/pattern_formatter.h"
-class my_formatter_flag : public spdlog::custom_flag_formatter
-{
-public:
-    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
-    {
-        std::string some_txt = "custom-flag";
-        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
-    }
-
-    std::unique_ptr<custom_flag_formatter> clone() const override
-    {
-        return spdlog::details::make_unique<my_formatter_flag>();
-    }
-};
-
-void custom_flags_example()
-{    
-    auto formatter = std::make_unique<spdlog::pattern_formatter>();
-    formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
-    spdlog::set_formatter(std::move(formatter));
-}
-
-```
-
----
-#### Custom error handler
-```c++
-void err_handler_example()
-{
-    // can be set globally or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) { spdlog::get("console")->error("*** LOGGER ERROR ***: {}", msg); });
-    spdlog::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
-}
-
-```
-
----
-#### syslog
-```c++
-#include "spdlog/sinks/syslog_sink.h"
-void syslog_example()
-{
-    std::string ident = "spdlog-example";
-    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
-    syslog_logger->warn("This is warning that will end up in syslog.");
-}
-```
----
-#### Android example
-```c++
-#include "spdlog/sinks/android_sink.h"
-void android_example()
-{
-    std::string tag = "spdlog-android";
-    auto android_logger = spdlog::android_logger_mt("android", tag);
-    android_logger->critical("Use \"adb shell logcat\" to view this message.");
-}
-```
-
----
-#### Load log levels from the env variable or argv
-
-```c++
-#include "spdlog/cfg/env.h"
-int main (int argc, char *argv[])
-{
-    spdlog::cfg::load_env_levels();
-    // or from the command line:
-    // ./example SPDLOG_LEVEL=info,mylogger=trace
-    // #include "spdlog/cfg/argv.h" // for loading levels from argv
-    // spdlog::cfg::load_argv_levels(argc, argv);
-}
-```
-So then you can:
-
-```console
-$ export SPDLOG_LEVEL=info,mylogger=trace
-$ ./example
-```
-
-
----
-#### Log file open/close event handlers
-```c++
-// You can get callbacks from spdlog before/after a log file has been opened or closed. 
-// This is useful for cleanup procedures or for adding something to the start/end of the log file.
-void file_events_example()
-{
-    // pass the spdlog::file_event_handlers to file sinks for open/close log file notifications
-    spdlog::file_event_handlers handlers;
-    handlers.before_open = [](spdlog::filename_t filename) { spdlog::info("Before opening {}", filename); };
-    handlers.after_open = [](spdlog::filename_t filename, std::FILE *fstream) { fputs("After opening\n", fstream); };
-    handlers.before_close = [](spdlog::filename_t filename, std::FILE *fstream) { fputs("Before closing\n", fstream); };
-    handlers.after_close = [](spdlog::filename_t filename) { spdlog::info("After closing {}", filename); };
-    auto my_logger = spdlog::basic_logger_st("some_logger", "logs/events-sample.txt", true, handlers);        
-}
-```
-
----
-#### Replace the Default Logger
-```c++
-void replace_default_logger_example()
-{
-    auto new_logger = spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
-    spdlog::set_default_logger(new_logger);
-    spdlog::info("new logger log message");
-}
-```
-
----
-#### Log to Qt with nice colors
-```c++
-#include "spdlog/spdlog.h"
-#include "spdlog/sinks/qt_sinks.h"
-MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent)
-{
-    setMinimumSize(640, 480);
-    auto log_widget = new QTextEdit(this);
-    setCentralWidget(log_widget);
-    int max_lines = 500; // keep the text widget to max 500 lines. remove old lines if needed.
-    auto logger = spdlog::qt_color_logger_mt("qt_logger", log_widget, max_lines);
-    logger->info("Some info message");
-}
-```
-
----
-## Benchmarks
-
-Below are some [benchmarks](https://github.com/gabime/spdlog/blob/v1.x/bench/bench.cpp) done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz
-
-#### Synchronous mode
-```
-[info] **************************************************************
-[info] Single thread, 1,000,000 iterations
-[info] **************************************************************
-[info] basic_st         Elapsed: 0.17 secs        5,777,626/sec
-[info] rotating_st      Elapsed: 0.18 secs        5,475,894/sec
-[info] daily_st         Elapsed: 0.20 secs        5,062,659/sec
-[info] empty_logger     Elapsed: 0.07 secs       14,127,300/sec
-[info] **************************************************************
-[info] C-string (400 bytes). Single thread, 1,000,000 iterations
-[info] **************************************************************
-[info] basic_st         Elapsed: 0.41 secs        2,412,483/sec
-[info] rotating_st      Elapsed: 0.72 secs        1,389,196/sec
-[info] daily_st         Elapsed: 0.42 secs        2,393,298/sec
-[info] null_st          Elapsed: 0.04 secs       27,446,957/sec
-[info] **************************************************************
-[info] 10 threads, competing over the same logger object, 1,000,000 iterations
-[info] **************************************************************
-[info] basic_mt         Elapsed: 0.60 secs        1,659,613/sec
-[info] rotating_mt      Elapsed: 0.62 secs        1,612,493/sec
-[info] daily_mt         Elapsed: 0.61 secs        1,638,305/sec
-[info] null_mt          Elapsed: 0.16 secs        6,272,758/sec
-```
-#### Asynchronous mode
-```
-[info] -------------------------------------------------
-[info] Messages     : 1,000,000
-[info] Threads      : 10
-[info] Queue        : 8,192 slots
-[info] Queue memory : 8,192 x 272 = 2,176 KB 
-[info] -------------------------------------------------
-[info] 
-[info] *********************************
-[info] Queue Overflow Policy: block
-[info] *********************************
-[info] Elapsed: 1.70784 secs     585,535/sec
-[info] Elapsed: 1.69805 secs     588,910/sec
-[info] Elapsed: 1.7026 secs      587,337/sec
-[info] 
-[info] *********************************
-[info] Queue Overflow Policy: overrun
-[info] *********************************
-[info] Elapsed: 0.372816 secs    2,682,285/sec
-[info] Elapsed: 0.379758 secs    2,633,255/sec
-[info] Elapsed: 0.373532 secs    2,677,147/sec
-
-```
-
-## Documentation
-Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages.
-
----
-
-Thanks to [JetBrains](https://www.jetbrains.com/?from=spdlog) for donating product licenses to help develop **spdlog** <a href="https://www.jetbrains.com/?from=spdlog"><img src="logos/jetbrains-variant-4.svg" width="94" align="center" /></a>
-
-
diff --git a/Dependencies/spdlog/Version-1.12.0 b/Dependencies/spdlog/Version-1.13.0
similarity index 100%
rename from Dependencies/spdlog/Version-1.12.0
rename to Dependencies/spdlog/Version-1.13.0
diff --git a/Dependencies/spdlog/appveyor.yml b/Dependencies/spdlog/appveyor.yml
deleted file mode 100644
index f2757f30..00000000
--- a/Dependencies/spdlog/appveyor.yml
+++ /dev/null
@@ -1,89 +0,0 @@
-version: 1.0.{build}
-image: Visual Studio 2017
-environment:
-  matrix:
-    - GENERATOR: '"Visual Studio 15 2017 Win64"'
-      BUILD_TYPE: Debug
-      BUILD_SHARED: 'OFF'
-      FATAL_ERRORS: 'OFF'
-      WCHAR: 'ON'
-      WCHAR_FILES: 'OFF'
-      BUILD_EXAMPLE: 'ON'
-      USE_STD_FORMAT: 'OFF'
-      CXX_STANDARD: 11
-    - GENERATOR: '"Visual Studio 15 2017 Win64"'
-      BUILD_TYPE: Release
-      BUILD_SHARED: 'OFF'
-      FATAL_ERRORS: 'OFF'
-      WCHAR: 'OFF'
-      WCHAR_FILES: 'OFF'
-      BUILD_EXAMPLE: 'ON'
-      USE_STD_FORMAT: 'OFF'
-      CXX_STANDARD: 11
-    - GENERATOR: '"Visual Studio 15 2017 Win64"'
-      BUILD_TYPE: Release
-      BUILD_SHARED: 'ON'
-      FATAL_ERRORS: 'OFF'
-      WCHAR: 'OFF'
-      WCHAR_FILES: 'OFF'
-      BUILD_EXAMPLE: 'ON'
-      USE_STD_FORMAT: 'OFF'
-      CXX_STANDARD: 11
-    - GENERATOR: '"Visual Studio 15 2017 Win64"'
-      BUILD_TYPE: Release
-      BUILD_SHARED: 'ON'
-      FATAL_ERRORS: 'OFF'
-      WCHAR: 'ON'
-      WCHAR_FILES: 'ON'
-      BUILD_EXAMPLE: 'OFF'
-      USE_STD_FORMAT: 'OFF'
-      CXX_STANDARD: 11
-    - GENERATOR: '"Visual Studio 16 2019" -A x64'
-      BUILD_TYPE: Release
-      BUILD_SHARED: 'ON'
-      FATAL_ERRORS: 'ON'
-      WCHAR: 'OFF'
-      WCHAR_FILES: 'OFF'
-      BUILD_EXAMPLE: 'OFF'
-      USE_STD_FORMAT: 'OFF'
-      CXX_STANDARD: 17
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-    - GENERATOR: '"Visual Studio 17 2022" -A x64'
-      BUILD_TYPE: Release
-      BUILD_SHARED: 'ON'
-      FATAL_ERRORS: 'ON'
-      WCHAR: 'OFF'
-      WCHAR_FILES: 'OFF'
-      BUILD_EXAMPLE: 'OFF'
-      USE_STD_FORMAT: 'ON'
-      CXX_STANDARD: 20
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
-    - GENERATOR: '"Visual Studio 17 2022" -A x64'
-      BUILD_TYPE: Release
-      BUILD_SHARED: 'ON'
-      FATAL_ERRORS: 'ON'
-      WCHAR: 'ON'
-      WCHAR_FILES: 'ON'
-      BUILD_EXAMPLE: 'OFF'
-      USE_STD_FORMAT: 'ON'
-      CXX_STANDARD: 20
-      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022
-build_script:
-  - cmd: >-
-      set
-
-      mkdir build
-
-      cd build
-
-      set PATH=%PATH%;C:\Program Files\Git\usr\bin
-
-      cmake -G %GENERATOR% -D CMAKE_BUILD_TYPE=%BUILD_TYPE% -D BUILD_SHARED_LIBS=%BUILD_SHARED% -D SPDLOG_WCHAR_SUPPORT=%WCHAR% -D SPDLOG_WCHAR_FILENAMES=%WCHAR_FILES% -D SPDLOG_BUILD_EXAMPLE=%BUILD_EXAMPLE% -D SPDLOG_BUILD_EXAMPLE_HO=%BUILD_EXAMPLE% -D SPDLOG_BUILD_TESTS=ON -D SPDLOG_BUILD_TESTS_HO=OFF -D SPDLOG_BUILD_WARNINGS=%FATAL_ERRORS% -D SPDLOG_USE_STD_FORMAT=%USE_STD_FORMAT% -D CMAKE_CXX_STANDARD=%CXX_STANDARD% ..
-
-      cmake --build . --config %BUILD_TYPE%
-
-before_test:
-  - set PATH=%PATH%;C:\projects\spdlog\build\_deps\catch2-build\src\%BUILD_TYPE%;C:\projects\spdlog\build\%BUILD_TYPE%
-  
-test_script:
-  - C:\projects\spdlog\build\tests\%BUILD_TYPE%\spdlog-utests.exe
diff --git a/Dependencies/spdlog/bench/CMakeLists.txt b/Dependencies/spdlog/bench/CMakeLists.txt
deleted file mode 100644
index 3806b24b..00000000
--- a/Dependencies/spdlog/bench/CMakeLists.txt
+++ /dev/null
@@ -1,37 +0,0 @@
-# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-cmake_minimum_required(VERSION 3.11)
-project(spdlog_bench CXX)
-
-if(NOT TARGET spdlog)
-    # Stand-alone build
-    find_package(spdlog CONFIG REQUIRED)
-endif()
-
-find_package(Threads REQUIRED)
-find_package(benchmark CONFIG)
-if(NOT benchmark_FOUND)
-    message(STATUS "Using CMake Version ${CMAKE_VERSION}")
-    # User can fetch googlebenchmark
-    message(STATUS "Downloading GoogleBenchmark")
-    include(FetchContent)
-
-    # disable tests
-    set(BENCHMARK_ENABLE_TESTING OFF CACHE INTERNAL "")
-    # Do not build and run googlebenchmark tests
-    FetchContent_Declare(googlebenchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG v1.6.0)
-    FetchContent_MakeAvailable(googlebenchmark)
-endif()
-
-add_executable(bench bench.cpp)
-spdlog_enable_warnings(bench)
-target_link_libraries(bench PRIVATE spdlog::spdlog)
-
-add_executable(async_bench async_bench.cpp)
-target_link_libraries(async_bench PRIVATE spdlog::spdlog)
-
-add_executable(latency latency.cpp)
-target_link_libraries(latency PRIVATE benchmark::benchmark spdlog::spdlog)
-
-add_executable(formatter-bench formatter-bench.cpp)
-target_link_libraries(formatter-bench PRIVATE benchmark::benchmark spdlog::spdlog)
diff --git a/Dependencies/spdlog/bench/async_bench.cpp b/Dependencies/spdlog/bench/async_bench.cpp
deleted file mode 100644
index a136c7bd..00000000
--- a/Dependencies/spdlog/bench/async_bench.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-//
-// bench.cpp : spdlog benchmarks
-//
-#include "spdlog/spdlog.h"
-#include "spdlog/async.h"
-#include "spdlog/sinks/basic_file_sink.h"
-
-#if defined(SPDLOG_USE_STD_FORMAT)
-    #include <format>
-#elif defined(SPDLOG_FMT_EXTERNAL)
-    #include <fmt/format.h>
-#else
-    #include "spdlog/fmt/bundled/format.h"
-#endif
-
-#include "utils.h"
-#include <atomic>
-#include <iostream>
-#include <memory>
-#include <string>
-#include <thread>
-
-using namespace std;
-using namespace std::chrono;
-using namespace spdlog;
-using namespace spdlog::sinks;
-using namespace utils;
-
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
-
-#ifdef _MSC_VER
-    #pragma warning(push)
-    #pragma warning(disable : 4996)  // disable fopen warning under msvc
-#endif                               // _MSC_VER
-
-int count_lines(const char *filename) {
-    int counter = 0;
-    auto *infile = fopen(filename, "r");
-    int ch;
-    while (EOF != (ch = getc(infile))) {
-        if ('\n' == ch) counter++;
-    }
-    fclose(infile);
-
-    return counter;
-}
-
-void verify_file(const char *filename, int expected_count) {
-    spdlog::info("Verifying {} to contain {} line..", filename, expected_count);
-    auto count = count_lines(filename);
-    if (count != expected_count) {
-        spdlog::error("Test failed. {} has {} lines instead of {}", filename, count,
-                      expected_count);
-        exit(1);
-    }
-    spdlog::info("Line count OK ({})\n", count);
-}
-
-#ifdef _MSC_VER
-    #pragma warning(pop)
-#endif
-
-int main(int argc, char *argv[]) {
-    int howmany = 1000000;
-    int queue_size = std::min(howmany + 2, 8192);
-    int threads = 10;
-    int iters = 3;
-
-    try {
-        spdlog::set_pattern("[%^%l%$] %v");
-        if (argc == 1) {
-            spdlog::info("Usage: {} <message_count> <threads> <q_size> <iterations>", argv[0]);
-            return 0;
-        }
-
-        if (argc > 1) howmany = atoi(argv[1]);
-        if (argc > 2) threads = atoi(argv[2]);
-        if (argc > 3) {
-            queue_size = atoi(argv[3]);
-            if (queue_size > 500000) {
-                spdlog::error("Max queue size allowed: 500,000");
-                exit(1);
-            }
-        }
-
-        if (argc > 4) iters = atoi(argv[4]);
-
-        auto slot_size = sizeof(spdlog::details::async_msg);
-        spdlog::info("-------------------------------------------------");
-        spdlog::info("Messages     : {:L}", howmany);
-        spdlog::info("Threads      : {:L}", threads);
-        spdlog::info("Queue        : {:L} slots", queue_size);
-        spdlog::info("Queue memory : {:L} x {:L} = {:L} KB ", queue_size, slot_size,
-                     (queue_size * slot_size) / 1024);
-        spdlog::info("Total iters  : {:L}", iters);
-        spdlog::info("-------------------------------------------------");
-
-        const char *filename = "logs/basic_async.log";
-        spdlog::info("");
-        spdlog::info("*********************************");
-        spdlog::info("Queue Overflow Policy: block");
-        spdlog::info("*********************************");
-        for (int i = 0; i < iters; i++) {
-            auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
-            auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
-            auto logger = std::make_shared<async_logger>(
-                "async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
-            bench_mt(howmany, std::move(logger), threads);
-            // verify_file(filename, howmany);
-        }
-
-        spdlog::info("");
-        spdlog::info("*********************************");
-        spdlog::info("Queue Overflow Policy: overrun");
-        spdlog::info("*********************************");
-        // do same test but discard oldest if queue is full instead of blocking
-        filename = "logs/basic_async-overrun.log";
-        for (int i = 0; i < iters; i++) {
-            auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
-            auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
-            auto logger =
-                std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp),
-                                               async_overflow_policy::overrun_oldest);
-            bench_mt(howmany, std::move(logger), threads);
-        }
-        spdlog::shutdown();
-    } catch (std::exception &ex) {
-        std::cerr << "Error: " << ex.what() << std::endl;
-        perror("Last error");
-        return 1;
-    }
-    return 0;
-}
-
-void thread_fun(std::shared_ptr<spdlog::logger> logger, int howmany) {
-    for (int i = 0; i < howmany; i++) {
-        logger->info("Hello logger: msg number {}", i);
-    }
-}
-
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_count) {
-    using std::chrono::high_resolution_clock;
-    vector<std::thread> threads;
-    auto start = high_resolution_clock::now();
-
-    int msgs_per_thread = howmany / thread_count;
-    int msgs_per_thread_mod = howmany % thread_count;
-    for (int t = 0; t < thread_count; ++t) {
-        if (t == 0 && msgs_per_thread_mod)
-            threads.push_back(
-                std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
-        else
-            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread));
-    }
-
-    for (auto &t : threads) {
-        t.join();
-    };
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::info("Elapsed: {} secs\t {:L}/sec", delta_d, int(howmany / delta_d));
-}
diff --git a/Dependencies/spdlog/bench/bench.cpp b/Dependencies/spdlog/bench/bench.cpp
deleted file mode 100644
index 609f4933..00000000
--- a/Dependencies/spdlog/bench/bench.cpp
+++ /dev/null
@@ -1,246 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-//
-// bench.cpp : spdlog benchmarks
-//
-#include "spdlog/spdlog.h"
-#include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/sinks/daily_file_sink.h"
-#include "spdlog/sinks/null_sink.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-
-#if defined(SPDLOG_USE_STD_FORMAT)
-    #include <format>
-#elif defined(SPDLOG_FMT_EXTERNAL)
-    #include <fmt/format.h>
-#else
-    #include "spdlog/fmt/bundled/format.h"
-#endif
-
-#include "utils.h"
-#include <atomic>
-#include <cstdlib>  // EXIT_FAILURE
-#include <memory>
-#include <string>
-#include <thread>
-
-void bench(int howmany, std::shared_ptr<spdlog::logger> log);
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_count);
-
-// void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log);
-// void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log);
-
-static const size_t file_size = 30 * 1024 * 1024;
-static const size_t rotating_files = 5;
-static const int max_threads = 1000;
-
-void bench_threaded_logging(size_t threads, int iters) {
-    spdlog::info("**************************************************************");
-    spdlog::info(spdlog::fmt_lib::format(
-        std::locale("en_US.UTF-8"), "Multi threaded: {:L} threads, {:L} messages", threads, iters));
-    spdlog::info("**************************************************************");
-
-    auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
-    bench_mt(iters, std::move(basic_mt), threads);
-    auto basic_mt_tracing =
-        spdlog::basic_logger_mt("basic_mt/backtrace-on", "logs/basic_mt.log", true);
-    basic_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(basic_mt_tracing), threads);
-
-    spdlog::info("");
-    auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size,
-                                                  rotating_files);
-    bench_mt(iters, std::move(rotating_mt), threads);
-    auto rotating_mt_tracing = spdlog::rotating_logger_mt(
-        "rotating_mt/backtrace-on", "logs/rotating_mt.log", file_size, rotating_files);
-    rotating_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(rotating_mt_tracing), threads);
-
-    spdlog::info("");
-    auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log");
-    bench_mt(iters, std::move(daily_mt), threads);
-    auto daily_mt_tracing = spdlog::daily_logger_mt("daily_mt/backtrace-on", "logs/daily_mt.log");
-    daily_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(daily_mt_tracing), threads);
-
-    spdlog::info("");
-    auto empty_logger = std::make_shared<spdlog::logger>("level-off");
-    empty_logger->set_level(spdlog::level::off);
-    bench(iters, empty_logger);
-    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
-    empty_logger_tracing->set_level(spdlog::level::off);
-    empty_logger_tracing->enable_backtrace(32);
-    bench(iters, empty_logger_tracing);
-}
-
-void bench_single_threaded(int iters) {
-    spdlog::info("**************************************************************");
-    spdlog::info(
-        spdlog::fmt_lib::format(std::locale("en_US.UTF-8"), "Single threaded: {} messages", iters));
-    spdlog::info("**************************************************************");
-
-    auto basic_st = spdlog::basic_logger_st("basic_st", "logs/basic_st.log", true);
-    bench(iters, std::move(basic_st));
-
-    auto basic_st_tracing =
-        spdlog::basic_logger_st("basic_st/backtrace-on", "logs/basic_st.log", true);
-    bench(iters, std::move(basic_st_tracing));
-
-    spdlog::info("");
-    auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size,
-                                                  rotating_files);
-    bench(iters, std::move(rotating_st));
-    auto rotating_st_tracing = spdlog::rotating_logger_st(
-        "rotating_st/backtrace-on", "logs/rotating_st.log", file_size, rotating_files);
-    rotating_st_tracing->enable_backtrace(32);
-    bench(iters, std::move(rotating_st_tracing));
-
-    spdlog::info("");
-    auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log");
-    bench(iters, std::move(daily_st));
-    auto daily_st_tracing = spdlog::daily_logger_st("daily_st/backtrace-on", "logs/daily_st.log");
-    daily_st_tracing->enable_backtrace(32);
-    bench(iters, std::move(daily_st_tracing));
-
-    spdlog::info("");
-    auto empty_logger = std::make_shared<spdlog::logger>("level-off");
-    empty_logger->set_level(spdlog::level::off);
-    bench(iters, empty_logger);
-
-    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
-    empty_logger_tracing->set_level(spdlog::level::off);
-    empty_logger_tracing->enable_backtrace(32);
-    bench(iters, empty_logger_tracing);
-}
-
-int main(int argc, char *argv[]) {
-    spdlog::set_automatic_registration(false);
-    spdlog::default_logger()->set_pattern("[%^%l%$] %v");
-    int iters = 250000;
-    size_t threads = 4;
-    try {
-        if (argc > 1) {
-            iters = std::stoi(argv[1]);
-        }
-        if (argc > 2) {
-            threads = std::stoul(argv[2]);
-        }
-
-        if (threads > max_threads) {
-            throw std::runtime_error(
-                spdlog::fmt_lib::format("Number of threads exceeds maximum({})", max_threads));
-        }
-
-        bench_single_threaded(iters);
-        bench_threaded_logging(1, iters);
-        bench_threaded_logging(threads, iters);
-    } catch (std::exception &ex) {
-        spdlog::error(ex.what());
-        return EXIT_FAILURE;
-    }
-    return EXIT_SUCCESS;
-}
-
-void bench(int howmany, std::shared_ptr<spdlog::logger> log) {
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-    using std::chrono::high_resolution_clock;
-
-    auto start = high_resolution_clock::now();
-    for (auto i = 0; i < howmany; ++i) {
-        log->info("Hello logger: msg number {}", i);
-    }
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-
-    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"),
-                                         "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(),
-                                         delta_d, size_t(howmany / delta_d)));
-    spdlog::drop(log->name());
-}
-
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_count) {
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-    using std::chrono::high_resolution_clock;
-
-    std::vector<std::thread> threads;
-    threads.reserve(thread_count);
-    auto start = high_resolution_clock::now();
-    for (size_t t = 0; t < thread_count; ++t) {
-        threads.emplace_back([&]() {
-            for (int j = 0; j < howmany / static_cast<int>(thread_count); j++) {
-                log->info("Hello logger: msg number {}", j);
-            }
-        });
-    }
-
-    for (auto &t : threads) {
-        t.join();
-    };
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::info(spdlog::fmt_lib::format(std::locale("en_US.UTF-8"),
-                                         "{:<30} Elapsed: {:0.2f} secs {:>16L}/sec", log->name(),
-                                         delta_d, size_t(howmany / delta_d)));
-    spdlog::drop(log->name());
-}
-
-/*
-void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log)
-{
-    using std::chrono::high_resolution_clock;
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-
-    auto orig_default = spdlog::default_logger();
-    spdlog::set_default_logger(log);
-    auto start = high_resolution_clock::now();
-    for (auto i = 0; i < howmany; ++i)
-    {
-        spdlog::info("Hello logger: msg number {}", i);
-    }
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::drop(log->name());
-    spdlog::set_default_logger(std::move(orig_default));
-    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany /
-delta_d));
-}
-
-void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log)
-{
-    using std::chrono::high_resolution_clock;
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-
-    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra
-metus cursus " "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus
-volutpat mi, eu consequat sem " "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam
-non dapibus eros. Donec fringilla dui sed " "augue pretium, nec scelerisque est maximus. Nullam
-convallis, sem nec blandit maximus, nisi turpis ornare " "nisl, sit amet volutpat neque massa eu
-odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
-
-    auto orig_default = spdlog::default_logger();
-    spdlog::set_default_logger(log);
-    auto start = high_resolution_clock::now();
-    for (auto i = 0; i < howmany; ++i)
-    {
-        spdlog::log(spdlog::level::info, msg);
-    }
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::drop(log->name());
-    spdlog::set_default_logger(std::move(orig_default));
-    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16}/sec", log->name(), delta_d, int(howmany /
-delta_d));
-}
-
-*/
\ No newline at end of file
diff --git a/Dependencies/spdlog/bench/formatter-bench.cpp b/Dependencies/spdlog/bench/formatter-bench.cpp
deleted file mode 100644
index 375a154f..00000000
--- a/Dependencies/spdlog/bench/formatter-bench.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#include "benchmark/benchmark.h"
-
-#include "spdlog/spdlog.h"
-#include "spdlog/pattern_formatter.h"
-
-void bench_formatter(benchmark::State &state, std::string pattern) {
-    auto formatter = spdlog::details::make_unique<spdlog::pattern_formatter>(pattern);
-    spdlog::memory_buf_t dest;
-    std::string logger_name = "logger-name";
-    const char *text =
-        "Hello. This is some message with length of 80                                   ";
-
-    spdlog::source_loc source_loc{"a/b/c/d/myfile.cpp", 123, "some_func()"};
-    spdlog::details::log_msg msg(source_loc, logger_name, spdlog::level::info, text);
-
-    for (auto _ : state) {
-        dest.clear();
-        formatter->format(msg, dest);
-        benchmark::DoNotOptimize(dest);
-    }
-}
-
-void bench_formatters() {
-    // basic patterns(single flag)
-    std::string all_flags = "+vtPnlLaAbBcCYDmdHIMSefFprRTXzEisg@luioO%";
-    std::vector<std::string> basic_patterns;
-    for (auto &flag : all_flags) {
-        auto pattern = std::string("%") + flag;
-        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
-
-        //        pattern = std::string("%16") + flag;
-        //        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
-        //
-        //        // bench center padding
-        //        pattern = std::string("%=16") + flag;
-        //        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
-    }
-
-    // complex patterns
-    std::vector<std::string> patterns = {
-        "[%D %X] [%l] [%n] %v",
-        "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] %v",
-        "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] [%t] %v",
-    };
-    for (auto &pattern : patterns) {
-        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern)
-            ->Iterations(2500000);
-    }
-}
-
-int main(int argc, char *argv[]) {
-    spdlog::set_pattern("[%^%l%$] %v");
-    if (argc != 2) {
-        spdlog::error("Usage: {} <pattern> (or \"all\" to bench all)", argv[0]);
-        exit(1);
-    }
-
-    std::string pattern = argv[1];
-    if (pattern == "all") {
-        bench_formatters();
-    } else {
-        benchmark::RegisterBenchmark(pattern.c_str(), &bench_formatter, pattern);
-    }
-    benchmark::Initialize(&argc, argv);
-    benchmark::RunSpecifiedBenchmarks();
-}
diff --git a/Dependencies/spdlog/bench/latency.cpp b/Dependencies/spdlog/bench/latency.cpp
deleted file mode 100644
index f63251e3..00000000
--- a/Dependencies/spdlog/bench/latency.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-//
-// latency.cpp : spdlog latency benchmarks
-//
-
-#include "benchmark/benchmark.h"
-
-#include "spdlog/spdlog.h"
-#include "spdlog/async.h"
-#include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/sinks/daily_file_sink.h"
-#include "spdlog/sinks/null_sink.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-
-void bench_c_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
-    const char *msg =
-        "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
-        "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, "
-        "eu consequat sem "
-        "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec "
-        "fringilla dui sed "
-        "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, "
-        "nisi turpis ornare "
-        "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue "
-        "nibh turpis duis.";
-
-    for (auto _ : state) {
-        logger->info(msg);
-    }
-}
-
-void bench_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
-    int i = 0;
-    for (auto _ : state) {
-        logger->info("Hello logger: msg number {}...............", ++i);
-    }
-}
-void bench_global_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
-    spdlog::set_default_logger(std::move(logger));
-    int i = 0;
-    for (auto _ : state) {
-        spdlog::info("Hello logger: msg number {}...............", ++i);
-    }
-}
-
-void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logger> logger) {
-    int i = 0;
-    benchmark::DoNotOptimize(i);       // prevent unused warnings
-    benchmark::DoNotOptimize(logger);  // prevent unused warnings
-    for (auto _ : state) {
-        SPDLOG_LOGGER_DEBUG(logger, "Hello logger: msg number {}...............", i++);
-    }
-}
-
-void bench_disabled_macro_global_logger(benchmark::State &state,
-                                        std::shared_ptr<spdlog::logger> logger) {
-    spdlog::set_default_logger(std::move(logger));
-    int i = 0;
-    benchmark::DoNotOptimize(i);       // prevent unused warnings
-    benchmark::DoNotOptimize(logger);  // prevent unused warnings
-    for (auto _ : state) {
-        SPDLOG_DEBUG("Hello logger: msg number {}...............", i++);
-    }
-}
-
-#ifdef __linux__
-void bench_dev_null() {
-    auto dev_null_st = spdlog::basic_logger_st("/dev/null_st", "/dev/null");
-    benchmark::RegisterBenchmark("/dev/null_st", bench_logger, std::move(dev_null_st))
-        ->UseRealTime();
-    spdlog::drop("/dev/null_st");
-
-    auto dev_null_mt = spdlog::basic_logger_mt("/dev/null_mt", "/dev/null");
-    benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))
-        ->UseRealTime();
-    spdlog::drop("/dev/null_mt");
-}
-#endif  // __linux__
-
-int main(int argc, char *argv[]) {
-    using spdlog::sinks::null_sink_mt;
-    using spdlog::sinks::null_sink_st;
-
-    size_t file_size = 30 * 1024 * 1024;
-    size_t rotating_files = 5;
-    int n_threads = benchmark::CPUInfo::Get().num_cpus;
-
-    auto full_bench = argc > 1 && std::string(argv[1]) == "full";
-
-    // disabled loggers
-    auto disabled_logger =
-        std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-    disabled_logger->set_level(spdlog::level::off);
-    benchmark::RegisterBenchmark("disabled-at-compile-time", bench_disabled_macro, disabled_logger);
-    benchmark::RegisterBenchmark("disabled-at-compile-time (global logger)",
-                                 bench_disabled_macro_global_logger, disabled_logger);
-    benchmark::RegisterBenchmark("disabled-at-runtime", bench_logger, disabled_logger);
-    benchmark::RegisterBenchmark("disabled-at-runtime (global logger)", bench_global_logger,
-                                 disabled_logger);
-    // with backtrace of 64
-    auto tracing_disabled_logger =
-        std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-    tracing_disabled_logger->enable_backtrace(64);
-    benchmark::RegisterBenchmark("disabled-at-runtime/backtrace", bench_logger,
-                                 tracing_disabled_logger);
-
-    auto null_logger_st =
-        std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
-    benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string,
-                                 std::move(null_logger_st));
-    benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st);
-    benchmark::RegisterBenchmark("null_sink_st (global logger)", bench_global_logger,
-                                 null_logger_st);
-    // with backtrace of 64
-    auto tracing_null_logger_st =
-        std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
-    tracing_null_logger_st->enable_backtrace(64);
-    benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st);
-
-#ifdef __linux
-    bench_dev_null();
-#endif  // __linux__
-
-    if (full_bench) {
-        // basic_st
-        auto basic_st = spdlog::basic_logger_st("basic_st", "latency_logs/basic_st.log", true);
-        benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime();
-        spdlog::drop("basic_st");
-        // with backtrace of 64
-        auto tracing_basic_st =
-            spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
-        tracing_basic_st->enable_backtrace(64);
-        benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger,
-                                     std::move(tracing_basic_st))
-            ->UseRealTime();
-        spdlog::drop("tracing_basic_st");
-
-        // rotating st
-        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log",
-                                                      file_size, rotating_files);
-        benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))
-            ->UseRealTime();
-        spdlog::drop("rotating_st");
-        // with backtrace of 64
-        auto tracing_rotating_st = spdlog::rotating_logger_st(
-            "tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size,
-            rotating_files);
-        benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger,
-                                     std::move(tracing_rotating_st))
-            ->UseRealTime();
-        spdlog::drop("tracing_rotating_st");
-
-        // daily st
-        auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log");
-        benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime();
-        spdlog::drop("daily_st");
-        auto tracing_daily_st =
-            spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
-        benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger,
-                                     std::move(tracing_daily_st))
-            ->UseRealTime();
-        spdlog::drop("tracing_daily_st");
-
-        //
-        // Multi threaded bench, 10 loggers using same logger concurrently
-        //
-        auto null_logger_mt =
-            std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-        benchmark::RegisterBenchmark("null_sink_mt", bench_logger, null_logger_mt)
-            ->Threads(n_threads)
-            ->UseRealTime();
-
-        // basic_mt
-        auto basic_mt = spdlog::basic_logger_mt("basic_mt", "latency_logs/basic_mt.log", true);
-        benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))
-            ->Threads(n_threads)
-            ->UseRealTime();
-        spdlog::drop("basic_mt");
-
-        // rotating mt
-        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log",
-                                                      file_size, rotating_files);
-        benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))
-            ->Threads(n_threads)
-            ->UseRealTime();
-        spdlog::drop("rotating_mt");
-
-        // daily mt
-        auto daily_mt = spdlog::daily_logger_mt("daily_mt", "latency_logs/daily_mt.log");
-        benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))
-            ->Threads(n_threads)
-            ->UseRealTime();
-        spdlog::drop("daily_mt");
-    }
-
-    // async
-    auto queue_size = 1024 * 1024 * 3;
-    auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
-    auto async_logger = std::make_shared<spdlog::async_logger>(
-        "async_logger", std::make_shared<null_sink_mt>(), std::move(tp),
-        spdlog::async_overflow_policy::overrun_oldest);
-    benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)
-        ->Threads(n_threads)
-        ->UseRealTime();
-
-    auto async_logger_tracing = std::make_shared<spdlog::async_logger>(
-        "async_logger_tracing", std::make_shared<null_sink_mt>(), std::move(tp),
-        spdlog::async_overflow_policy::overrun_oldest);
-    async_logger_tracing->enable_backtrace(32);
-    benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)
-        ->Threads(n_threads)
-        ->UseRealTime();
-
-    benchmark::Initialize(&argc, argv);
-    benchmark::RunSpecifiedBenchmarks();
-}
diff --git a/Dependencies/spdlog/bench/utils.h b/Dependencies/spdlog/bench/utils.h
deleted file mode 100644
index 1828fc08..00000000
--- a/Dependencies/spdlog/bench/utils.h
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <iomanip>
-#include <locale>
-#include <sstream>
-
-namespace utils {
-
-template <typename T>
-inline std::string format(const T &value) {
-    static std::locale loc("");
-    std::stringstream ss;
-    ss.imbue(loc);
-    ss << value;
-    return ss.str();
-}
-
-template <>
-inline std::string format(const double &value) {
-    static std::locale loc("");
-    std::stringstream ss;
-    ss.imbue(loc);
-    ss << std::fixed << std::setprecision(1) << value;
-    return ss.str();
-}
-
-}  // namespace utils
diff --git a/Dependencies/spdlog/cmake/ide.cmake b/Dependencies/spdlog/cmake/ide.cmake
deleted file mode 100644
index a0656a5e..00000000
--- a/Dependencies/spdlog/cmake/ide.cmake
+++ /dev/null
@@ -1,18 +0,0 @@
-# ---------------------------------------------------------------------------------------
-# IDE support for headers
-# ---------------------------------------------------------------------------------------
-set(SPDLOG_HEADERS_DIR "${CMAKE_CURRENT_LIST_DIR}/../include")
-
-file(GLOB SPDLOG_TOP_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/*.h")
-file(GLOB SPDLOG_DETAILS_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/details/*.h")
-file(GLOB SPDLOG_SINKS_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/sinks/*.h")
-file(GLOB SPDLOG_FMT_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/fmt/*.h")
-file(GLOB SPDLOG_FMT_BUNDELED_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/fmt/bundled/*.h")
-set(SPDLOG_ALL_HEADERS ${SPDLOG_TOP_HEADERS} ${SPDLOG_DETAILS_HEADERS} ${SPDLOG_SINKS_HEADERS} ${SPDLOG_FMT_HEADERS}
-                       ${SPDLOG_FMT_BUNDELED_HEADERS})
-
-source_group("Header Files\\spdlog" FILES ${SPDLOG_TOP_HEADERS})
-source_group("Header Files\\spdlog\\details" FILES ${SPDLOG_DETAILS_HEADERS})
-source_group("Header Files\\spdlog\\sinks" FILES ${SPDLOG_SINKS_HEADERS})
-source_group("Header Files\\spdlog\\fmt" FILES ${SPDLOG_FMT_HEADERS})
-source_group("Header Files\\spdlog\\fmt\\bundled\\" FILES ${SPDLOG_FMT_BUNDELED_HEADERS})
diff --git a/Dependencies/spdlog/cmake/pch.h.in b/Dependencies/spdlog/cmake/pch.h.in
deleted file mode 100644
index a5f94150..00000000
--- a/Dependencies/spdlog/cmake/pch.h.in
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-#pragma once
-
-// details/pattern_formatter-inl.h
-// fmt/bin_to_hex.h
-// fmt/bundled/format-inl.h
-#include <cctype>
-
-// details/file_helper-inl.h
-// details/os-inl.h
-// fmt/bundled/core.h
-// fmt/bundled/posix.h
-// logger-inl.h
-// sinks/daily_file_sink.h
-// sinks/stdout_sinks.h
-#include <cstdio>
-
-// details/os-inl.h
-// fmt/bundled/posix.h
-#include <cstdlib>
-
-// details/os-inl.h
-// details/pattern_formatter-inl.h
-// fmt/bundled/core.h
-// fmt/bundled/format-inl.h
-#include <cstring>
-
-// details/os-inl.h
-// details/os.h
-// details/pattern_formatter-inl.h
-// details/pattern_formatter.h
-// fmt/bundled/chrono.h
-// sinks/daily_file_sink.h
-// sinks/rotating_file_sink-inl.h
-#include <ctime>
-
-// fmt/bundled/format-inl.h
-#include <climits>
-
-// fmt/bundled/format-inl.h
-#include <cwchar>
-
-// fmt/bundled/format-inl.h
-// fmt/bundled/format.h
-#include <cmath>
-
-// fmt/bundled/format-inl.h
-#include <cstdarg>
-
-// details/file_helper-inl.h
-// fmt/bundled/format.h
-// fmt/bundled/posix.h
-// sinks/rotating_file_sink-inl.h
-#include <cerrno>
-
-// details/circular_q.h
-// details/thread_pool-inl.h
-// fmt/bundled/format-inl.h
-#include <cassert>
-
-// async_logger-inl.h
-// cfg/helpers-inl.h
-// log_levels.h
-// common.h
-// details/file_helper-inl.h
-// details/log_msg.h
-// details/os-inl.h
-// details/pattern_formatter-inl.h
-// details/pattern_formatter.h
-// details/registry-inl.h
-// details/registry.h
-// details/tcp_client-windows.h
-// details/tcp_client.h
-// fmt/bundled/core.h
-// sinks/android_sink.h
-// sinks/ansicolor_sink.h
-// sinks/basic_file_sink.h
-// sinks/daily_file_sink.h
-// sinks/dup_filter_sink.h
-// sinks/msvc_sink.h
-// sinks/ringbuffer_sink.h
-// sinks/rotating_file_sink-inl.h
-// sinks/rotating_file_sink.h
-// sinks/syslog_sink.h
-// sinks/tcp_sink.h
-// sinks/win_eventlog_sink.h
-// sinks/wincolor_sink.h
-// spdlog.h:
-#include <string>
-
-// cfg/helpers-inl.h
-// fmt/bundled/chrono.h
-#include <sstream>
-
-// fmt/bundled/ostream.h
-// sinks/ostream_sink.h
-#include <ostream>
-
-// cfg/log_levels.h
-// details/registry-inl.h
-// details/registry.h
-#include <unordered_map>
-
-// details/circular_q.h
-// details/pattern_formatter-inl.h
-// details/pattern_formatter.h
-// details/thread_pool.h
-// fmt/bundled/compile.h
-// logger.h
-// sinks/dist_sink.h
-// sinks/ringbuffer_sink.h
-// sinks/win_eventlog_sink.h
-#include <vector>
-
-// details/os-inl.h
-// details/pattern_formatter-inl.h
-// sinks/ansicolor_sink.h
-// sinks/syslog_sink.h
-// sinks/systemd_sink.h
-// sinks/wincolor_sink.h
-#include <array>
-
-// details/file_helper-inl.h
-// details/file_helper.h
-// sinks/rotating_file_sink-inl.h
-#include <tuple>
-
-// details/os-inl.h
-// fmt/bundled/format.h
-// fmt/bundled/printf.h
-#include <limits>
-
-// common.h
-// details/backtracer.h
-// details/null_mutex.h
-#include <atomic>
-
-// common.h
-// details/backtracer.h
-// details/null_mutex.h
-#include <locale>
-
-// common.h
-#include <initializer_list>
-
-// common.h
-#include <exception>
-
-// common.h
-// details/fmt_helper.h
-// fmt/bundled/core.h
-// fmt/bundled/ranges.h
-#include <type_traits>
-
-// cfg/helpers-inl.h
-// details/null_mutex.h
-// details/pattern_formatter-inl.h
-#include <utility>
-
-// async.h
-// async_logger-inl.h
-// common.h
-// details/pattern_formatter-inl.h
-// details/pattern_formatter.h
-// details/registry-inl.h
-// details/registry.h
-// details/thread_pool.h
-// fmt/bundled/format.h
-// sinks/ansicolor_sink.h
-// sinks/base_sink-inl.h
-// sinks/dist_sink.h
-// sinks/stdout_sinks-inl.h
-// sinks/wincolor_sink.h
-// spdlog.h
-#include <memory>
-
-// async.h
-// common.h
-// details/backtracer.h
-// details/periodic_worker.h
-// details/registry-inl.h
-// details/registry.h
-// details/thread_pool.h
-// sinks/tcp_sink.h
-// spdlog.h
-#include <functional>
-
-// details/mpmc_blocking_q.h
-// details/periodic_worker.h
-#include <condition_variable>
-
-// details/os-inl.h
-// fmt/bundled/format.h
-// fmt/bundled/printf.h
-// sinks/dist_sink.h
-#include <algorithm>
-
-// common.h
-// details/file_helper-inl.h
-// details/fmt_helper.h
-// details/os-inl.h
-// details/pattern_formatter-inl.h
-// details/pattern_formatter.h
-// details/periodic_worker.h
-// details/registry-inl.h
-// details/registry.h
-// details/thread_pool.h
-// fmt/bundled/chrono.h
-// sinks/android_sink.h
-// sinks/daily_file_sink.h
-// sinks/dup_filter_sink.h
-// sinks/rotating_file_sink-inl.h
-// sinks/rotating_file_sink.h
-// sinks/tcp_sink.h
-// spdlog.h
-#include <chrono>
-
-// details/file_helper-inl.h
-// details/os-inl.h
-// details/pattern_formatter-inl.h
-// details/periodic_worker.h
-// details/thread_pool.h
-// sinks/android_sink.h
-#include <thread>
-
-// async.h
-// details/backtracer.h
-// details/console_globals.h
-// details/mpmc_blocking_q.h
-// details/pattern_formatter-inl.h
-// details/periodic_worker.h
-// details/registry.h
-// sinks/android_sink.h
-// sinks/ansicolor_sink.h
-// sinks/basic_file_sink.h
-// sinks/daily_file_sink.h
-// sinks/dist_sink.h
-// sinks/dup_filter_sink.h
-// sinks/msvc_sink.h
-// sinks/null_sink.h
-// sinks/ostream_sink.h
-// sinks/ringbuffer_sink.h
-// sinks/rotating_file_sink-inl.h
-// sinks/rotating_file_sink.h
-// sinks/tcp_sink.h
-// sinks/win_eventlog_sink.h
-// sinks/wincolor_sink.h
-//
-// color_sinks.cpp
-// file_sinks.cpp
-// spdlog.cpp
-// stdout_sinks.cpp
-#include <mutex>
-
-// spdlog
-#include <spdlog/common.h>
\ No newline at end of file
diff --git a/Dependencies/spdlog/cmake/spdlog.pc.in b/Dependencies/spdlog/cmake/spdlog.pc.in
deleted file mode 100644
index ffab5d6f..00000000
--- a/Dependencies/spdlog/cmake/spdlog.pc.in
+++ /dev/null
@@ -1,13 +0,0 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=${prefix}
-includedir=@PKG_CONFIG_INCLUDEDIR@
-libdir=@PKG_CONFIG_LIBDIR@
-
-Name: lib@PROJECT_NAME@
-Description: Fast C++ logging library.
-URL: https://github.com/gabime/@PROJECT_NAME@
-Version: @SPDLOG_VERSION@
-CFlags: -I${includedir} @PKG_CONFIG_DEFINES@
-Libs: -L${libdir} -lspdlog -pthread
-Requires: @PKG_CONFIG_REQUIRES@
-
diff --git a/Dependencies/spdlog/cmake/spdlogCPack.cmake b/Dependencies/spdlog/cmake/spdlogCPack.cmake
deleted file mode 100644
index 58bf4013..00000000
--- a/Dependencies/spdlog/cmake/spdlogCPack.cmake
+++ /dev/null
@@ -1,60 +0,0 @@
-set(CPACK_GENERATOR "TGZ;ZIP" CACHE STRING "Semicolon separated list of generators")
-
-set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY 0)
-set(CPACK_INSTALL_CMAKE_PROJECTS "${CMAKE_BINARY_DIR}" "${PROJECT_NAME}" ALL .)
-
-set(CPACK_PROJECT_URL "https://github.com/gabime/spdlog")
-set(CPACK_PACKAGE_VENDOR "Gabi Melman")
-set(CPACK_PACKAGE_CONTACT "Gabi Melman <gmelman1@gmail.com>")
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Fast C++ logging library")
-set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
-set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
-set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
-set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
-if(PROJECT_VERSION_TWEAK)
-    set(CPACK_PACKAGE_VERSION ${CPACK_PACKAGE_VERSION}.${PROJECT_VERSION_TWEAK})
-endif()
-set(CPACK_PACKAGE_RELOCATABLE ON CACHE BOOL "Build relocatable package")
-
-set(CPACK_RPM_PACKAGE_LICENSE "MIT")
-set(CPACK_RPM_PACKAGE_GROUP "Development/Libraries")
-set(CPACK_DEBIAN_PACKAGE_SECTION "libs")
-set(CPACK_RPM_PACKAGE_URL ${CPACK_PROJECT_URL})
-set(CPACK_DEBIAN_PACKAGE_HOMEPAGE ${CPACK_PROJECT_URL})
-set(CPACK_RPM_PACKAGE_DESCRIPTION "Very fast, header-only/compiled, C++ logging library.")
-set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "Very fast, header-only/compiled, C++ logging library.")
-
-if(CPACK_PACKAGE_NAME)
-    set(CPACK_RPM_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
-    set(CPACK_DEBIAN_FILE_NAME "${CPACK_PACKAGE_NAME}-${CPACK_PACKAGE_VERSION}")
-else()
-    set(CPACK_RPM_FILE_NAME "${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}")
-    set(CPACK_DEBIAN_FILE_NAME "${PROJECT_NAME}-${CPACK_PACKAGE_VERSION}")
-    set(CPACK_RPM_PACKAGE_NAME "${PROJECT_NAME}")
-    set(CPACK_DEBIAN_PACKAGE_NAME "${PROJECT_NAME}")
-endif()
-
-if(CPACK_RPM_PACKAGE_RELEASE)
-    set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}-${CPACK_RPM_PACKAGE_RELEASE}")
-endif()
-if(CPACK_DEBIAN_PACKAGE_RELEASE)
-    set(CPACK_DEBIAN_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}-${CPACK_DEBIAN_PACKAGE_RELEASE}")
-endif()
-
-if(CPACK_RPM_PACKAGE_ARCHITECTURE)
-    set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}.${CPACK_RPM_PACKAGE_ARCHITECTURE}")
-endif()
-if(CPACK_DEBIAN_PACKAGE_ARCHITECTURE)
-    set(CPACK_DEBIAN_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}.${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")
-endif()
-set(CPACK_RPM_FILE_NAME "${CPACK_RPM_FILE_NAME}.rpm")
-set(CPACK_DEBIAN_FILE_NAME "${CPACK_DEBIAN_FILE_NAME}.deb")
-
-if(NOT CPACK_PACKAGE_RELOCATABLE)
-    # Depend on pkgconfig rpm to create the system pkgconfig folder
-    set(CPACK_RPM_PACKAGE_REQUIRES pkgconfig)
-    set(CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION
-        "${CPACK_PACKAGING_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/pkgconfig")
-endif()
-
-include(CPack)
diff --git a/Dependencies/spdlog/cmake/spdlogConfig.cmake.in b/Dependencies/spdlog/cmake/spdlogConfig.cmake.in
deleted file mode 100644
index d8a3ac16..00000000
--- a/Dependencies/spdlog/cmake/spdlogConfig.cmake.in
+++ /dev/null
@@ -1,20 +0,0 @@
-# Copyright(c) 2019 spdlog authors
-# Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-@PACKAGE_INIT@
-
-find_package(Threads REQUIRED)
-
-set(SPDLOG_FMT_EXTERNAL @SPDLOG_FMT_EXTERNAL@)
-set(SPDLOG_FMT_EXTERNAL_HO @SPDLOG_FMT_EXTERNAL_HO@)
-set(config_targets_file @config_targets_file@)
-
-if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO)
-    include(CMakeFindDependencyMacro)
-    find_dependency(fmt CONFIG)
-endif()
-
-
-include("${CMAKE_CURRENT_LIST_DIR}/${config_targets_file}")
-
-check_required_components(spdlog)
diff --git a/Dependencies/spdlog/cmake/utils.cmake b/Dependencies/spdlog/cmake/utils.cmake
deleted file mode 100644
index 85fcd80f..00000000
--- a/Dependencies/spdlog/cmake/utils.cmake
+++ /dev/null
@@ -1,62 +0,0 @@
-# Get spdlog version from include/spdlog/version.h and put it in SPDLOG_VERSION
-function(spdlog_extract_version)
-    file(READ "${CMAKE_CURRENT_LIST_DIR}/include/spdlog/version.h" file_contents)
-    string(REGEX MATCH "SPDLOG_VER_MAJOR ([0-9]+)" _ "${file_contents}")
-    if(NOT CMAKE_MATCH_COUNT EQUAL 1)
-        message(FATAL_ERROR "Could not extract major version number from spdlog/version.h")
-    endif()
-    set(ver_major ${CMAKE_MATCH_1})
-
-    string(REGEX MATCH "SPDLOG_VER_MINOR ([0-9]+)" _ "${file_contents}")
-    if(NOT CMAKE_MATCH_COUNT EQUAL 1)
-        message(FATAL_ERROR "Could not extract minor version number from spdlog/version.h")
-    endif()
-
-    set(ver_minor ${CMAKE_MATCH_1})
-    string(REGEX MATCH "SPDLOG_VER_PATCH ([0-9]+)" _ "${file_contents}")
-    if(NOT CMAKE_MATCH_COUNT EQUAL 1)
-        message(FATAL_ERROR "Could not extract patch version number from spdlog/version.h")
-    endif()
-    set(ver_patch ${CMAKE_MATCH_1})
-
-    set(SPDLOG_VERSION_MAJOR ${ver_major} PARENT_SCOPE)
-    set(SPDLOG_VERSION_MINOR ${ver_minor} PARENT_SCOPE)
-    set(SPDLOG_VERSION_PATCH ${ver_patch} PARENT_SCOPE)
-    set(SPDLOG_VERSION "${ver_major}.${ver_minor}.${ver_patch}" PARENT_SCOPE)
-endfunction()
-
-# Turn on warnings on the given target
-function(spdlog_enable_warnings target_name)
-    if(SPDLOG_BUILD_WARNINGS)
-        if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-            list(APPEND MSVC_OPTIONS "/W3")
-            if(MSVC_VERSION GREATER 1900) # Allow non fatal security warnings for msvc 2015
-                list(APPEND MSVC_OPTIONS "/WX")
-            endif()
-        endif()
-
-        target_compile_options(
-            ${target_name}
-            PRIVATE $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:GNU>>:
-                    -Wall
-                    -Wextra
-                    -Wconversion
-                    -pedantic
-                    -Werror
-                    -Wfatal-errors>
-                    $<$<CXX_COMPILER_ID:MSVC>:${MSVC_OPTIONS}>)
-    endif()
-endfunction()
-
-# Enable address sanitizer (gcc/clang only)
-function(spdlog_enable_sanitizer target_name)
-    if(NOT CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
-        message(FATAL_ERROR "Sanitizer supported only for gcc/clang")
-    endif()
-    message(STATUS "Address sanitizer enabled")
-    target_compile_options(${target_name} PRIVATE -fsanitize=address,undefined)
-    target_compile_options(${target_name} PRIVATE -fno-sanitize=signed-integer-overflow)
-    target_compile_options(${target_name} PRIVATE -fno-sanitize-recover=all)
-    target_compile_options(${target_name} PRIVATE -fno-omit-frame-pointer)
-    target_link_libraries(${target_name} PRIVATE -fsanitize=address,undefined -fuse-ld=gold)
-endfunction()
diff --git a/Dependencies/spdlog/cmake/version.rc.in b/Dependencies/spdlog/cmake/version.rc.in
deleted file mode 100644
index a86c1385..00000000
--- a/Dependencies/spdlog/cmake/version.rc.in
+++ /dev/null
@@ -1,42 +0,0 @@
-#define APSTUDIO_READONLY_SYMBOLS
-#include <windows.h>
-#undef APSTUDIO_READONLY_SYMBOLS
-
-LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
-
-
-VS_VERSION_INFO VERSIONINFO
- FILEVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0
- PRODUCTVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0
- FILEFLAGSMASK 0x3fL
-#ifdef _DEBUG
- FILEFLAGS 0x1L
-#else
- FILEFLAGS 0x0L
-#endif
- FILEOS 0x40004L
- FILETYPE 0x2L
- FILESUBTYPE 0x0L
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904b0"
-        BEGIN
-            VALUE "FileDescription", "spdlog dll\0"
-            VALUE "FileVersion", "@SPDLOG_VERSION@.0\0"
-            VALUE "InternalName", "spdlog.dll\0"
-            VALUE "LegalCopyright", "Copyright (C) spdlog\0"
-            VALUE "ProductName", "spdlog\0"
-            VALUE "ProductVersion", "@SPDLOG_VERSION@.0\0"
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END
-
-
-
-
-
diff --git a/Dependencies/spdlog/example/CMakeLists.txt b/Dependencies/spdlog/example/CMakeLists.txt
deleted file mode 100644
index da1ed4e2..00000000
--- a/Dependencies/spdlog/example/CMakeLists.txt
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-cmake_minimum_required(VERSION 3.11)
-project(spdlog_examples CXX)
-
-if(NOT TARGET spdlog)
-    # Stand-alone build
-    find_package(spdlog REQUIRED)
-endif()
-
-# ---------------------------------------------------------------------------------------
-# Example of using pre-compiled library
-# ---------------------------------------------------------------------------------------
-add_executable(example example.cpp)
-target_link_libraries(example PRIVATE spdlog::spdlog $<$<BOOL:${MINGW}>:ws2_32>)
-
-# ---------------------------------------------------------------------------------------
-# Example of using header-only library
-# ---------------------------------------------------------------------------------------
-if(SPDLOG_BUILD_EXAMPLE_HO)
-    add_executable(example_header_only example.cpp)
-    target_link_libraries(example_header_only PRIVATE spdlog::spdlog_header_only)
-endif()
diff --git a/Dependencies/spdlog/example/example.cpp b/Dependencies/spdlog/example/example.cpp
deleted file mode 100644
index 22109463..00000000
--- a/Dependencies/spdlog/example/example.cpp
+++ /dev/null
@@ -1,378 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-// spdlog usage example
-
-#include <cstdio>
-#include <chrono>
-
-void load_levels_example();
-void stdout_logger_example();
-void basic_example();
-void rotating_example();
-void daily_example();
-void callback_example();
-void async_example();
-void binary_example();
-void vector_example();
-void stopwatch_example();
-void trace_example();
-void multi_sink_example();
-void user_defined_example();
-void err_handler_example();
-void syslog_example();
-void udp_example();
-void custom_flags_example();
-void file_events_example();
-void replace_default_logger_example();
-
-#include "spdlog/spdlog.h"
-#include "spdlog/cfg/env.h"   // support for loading levels from the environment variable
-#include "spdlog/fmt/ostr.h"  // support for user defined types
-
-int main(int, char *[]) {
-    // Log levels can be loaded from argv/env using "SPDLOG_LEVEL"
-    load_levels_example();
-
-    spdlog::info("Welcome to spdlog version {}.{}.{}  !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR,
-                 SPDLOG_VER_PATCH);
-
-    spdlog::warn("Easy padding in numbers like {:08d}", 12);
-    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-    spdlog::info("Support for floats {:03.2f}", 1.23456);
-    spdlog::info("Positional args are {1} {0}..", "too", "supported");
-    spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left");
-
-    // Runtime log levels
-    spdlog::set_level(spdlog::level::info);  // Set global log level to info
-    spdlog::debug("This message should not be displayed!");
-    spdlog::set_level(spdlog::level::trace);  // Set specific logger's log level
-    spdlog::debug("This message should be displayed..");
-
-    // Customize msg format for all loggers
-    spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v");
-    spdlog::info("This an info message with custom format");
-    spdlog::set_pattern("%+");  // back to default format
-    spdlog::set_level(spdlog::level::info);
-
-    // Backtrace support
-    // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection.
-    // When needed, call dump_backtrace() to see what happened:
-    spdlog::enable_backtrace(10);  // create ring buffer with capacity of 10  messages
-    for (int i = 0; i < 100; i++) {
-        spdlog::debug("Backtrace message {}", i);  // not logged..
-    }
-    // e.g. if some error happened:
-    spdlog::dump_backtrace();  // log them now!
-
-    try {
-        stdout_logger_example();
-        basic_example();
-        rotating_example();
-        daily_example();
-        callback_example();
-        async_example();
-        binary_example();
-        vector_example();
-        multi_sink_example();
-        user_defined_example();
-        err_handler_example();
-        trace_example();
-        stopwatch_example();
-        udp_example();
-        custom_flags_example();
-        file_events_example();
-        replace_default_logger_example();
-
-        // Flush all *registered* loggers using a worker thread every 3 seconds.
-        // note: registered loggers *must* be thread safe for this to work correctly!
-        spdlog::flush_every(std::chrono::seconds(3));
-
-        // Apply some function on all registered loggers
-        spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
-
-        // Release all spdlog resources, and drop all loggers in the registry.
-        // This is optional (only mandatory if using windows + async log).
-        spdlog::shutdown();
-    }
-
-    // Exceptions will only be thrown upon failed logger or sink construction (not during logging).
-    catch (const spdlog::spdlog_ex &ex) {
-        std::printf("Log initialization failed: %s\n", ex.what());
-        return 1;
-    }
-}
-
-#include "spdlog/sinks/stdout_color_sinks.h"
-// or #include "spdlog/sinks/stdout_sinks.h" if no colors needed.
-void stdout_logger_example() {
-    // Create color multi threaded logger.
-    auto console = spdlog::stdout_color_mt("console");
-    // or for stderr:
-    // auto console = spdlog::stderr_color_mt("error-logger");
-}
-
-#include "spdlog/sinks/basic_file_sink.h"
-void basic_example() {
-    // Create basic file logger (not rotated).
-    auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt", true);
-}
-
-#include "spdlog/sinks/rotating_file_sink.h"
-void rotating_example() {
-    // Create a file rotating logger with 5mb size max and 3 rotated files.
-    auto rotating_logger =
-        spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
-}
-
-#include "spdlog/sinks/daily_file_sink.h"
-void daily_example() {
-    // Create a daily logger - a new file is created every day on 2:30am.
-    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
-}
-
-#include "spdlog/sinks/callback_sink.h"
-void callback_example() {
-    // Create the logger
-    auto logger = spdlog::callback_logger_mt("custom_callback_logger",
-                                             [](const spdlog::details::log_msg & /*msg*/) {
-                                                 // do what you need to do with msg
-                                             });
-}
-
-#include "spdlog/cfg/env.h"
-void load_levels_example() {
-    // Set the log level to "info" and mylogger to "trace":
-    // SPDLOG_LEVEL=info,mylogger=trace && ./example
-    spdlog::cfg::load_env_levels();
-    // or from command line:
-    // ./example SPDLOG_LEVEL=info,mylogger=trace
-    // #include "spdlog/cfg/argv.h" // for loading levels from argv
-    // spdlog::cfg::load_argv_levels(args, argv);
-}
-
-#include "spdlog/async.h"
-void async_example() {
-    // Default thread pool settings can be modified *before* creating the async logger:
-    // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
-    auto async_file =
-        spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
-    // alternatively:
-    // auto async_file =
-    // spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger",
-    // "logs/async_log.txt");
-
-    for (int i = 1; i < 101; ++i) {
-        async_file->info("Async message #{}", i);
-    }
-}
-
-// Log binary data as hex.
-// Many types of std::container<char> types can be used.
-// Iterator ranges are supported too.
-// Format flags:
-// {:X} - print in uppercase.
-// {:s} - don't separate each byte with space.
-// {:p} - don't print the position on each line start.
-// {:n} - don't split the output to lines.
-
-#if !defined SPDLOG_USE_STD_FORMAT || defined(_MSC_VER)
-    #include "spdlog/fmt/bin_to_hex.h"
-void binary_example() {
-    std::vector<char> buf;
-    for (int i = 0; i < 80; i++) {
-        buf.push_back(static_cast<char>(i & 0xff));
-    }
-    spdlog::info("Binary example: {}", spdlog::to_hex(buf));
-    spdlog::info("Another binary example:{:n}",
-                 spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
-    // more examples:
-    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
-    // logger->info("hexdump style: {:a}", spdlog::to_hex(buf));
-    // logger->info("hexdump style, 20 chars per line {:a}", spdlog::to_hex(buf, 20));
-}
-#else
-void binary_example() {
-    // not supported with std::format yet
-}
-#endif
-
-// Log a vector of numbers
-#ifndef SPDLOG_USE_STD_FORMAT
-    #include "spdlog/fmt/ranges.h"
-void vector_example() {
-    std::vector<int> vec = {1, 2, 3};
-    spdlog::info("Vector example: {}", vec);
-}
-
-#else
-void vector_example() {}
-#endif
-
-// ! DSPDLOG_USE_STD_FORMAT
-
-// Compile time log levels.
-// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
-void trace_example() {
-    // trace from default logger
-    SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
-    // debug from default logger
-    SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);
-
-    // trace from logger object
-    auto logger = spdlog::get("file_logger");
-    SPDLOG_LOGGER_TRACE(logger, "another trace message");
-}
-
-// stopwatch example
-#include "spdlog/stopwatch.h"
-#include <thread>
-void stopwatch_example() {
-    spdlog::stopwatch sw;
-    std::this_thread::sleep_for(std::chrono::milliseconds(123));
-    spdlog::info("Stopwatch: {} seconds", sw);
-}
-
-#include "spdlog/sinks/udp_sink.h"
-void udp_example() {
-    spdlog::sinks::udp_sink_config cfg("127.0.0.1", 11091);
-    auto my_logger = spdlog::udp_logger_mt("udplog", cfg);
-    my_logger->set_level(spdlog::level::debug);
-    my_logger->info("hello world");
-}
-
-// A logger with multiple sinks (stdout and file) - each with a different format and log level.
-void multi_sink_example() {
-    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    console_sink->set_level(spdlog::level::warn);
-    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
-
-    auto file_sink =
-        std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
-    file_sink->set_level(spdlog::level::trace);
-
-    spdlog::logger logger("multi_sink", {console_sink, file_sink});
-    logger.set_level(spdlog::level::debug);
-    logger.warn("this should appear in both console and file");
-    logger.info("this message should not appear in the console, only in the file");
-}
-
-// User defined types logging
-struct my_type {
-    int i = 0;
-    explicit my_type(int i)
-        : i(i){};
-};
-
-#ifndef SPDLOG_USE_STD_FORMAT  // when using fmtlib
-template <>
-struct fmt::formatter<my_type> : fmt::formatter<std::string> {
-    auto format(my_type my, format_context &ctx) -> decltype(ctx.out()) {
-        return fmt::format_to(ctx.out(), "[my_type i={}]", my.i);
-    }
-};
-
-#else  // when using std::format
-template <>
-struct std::formatter<my_type> : std::formatter<std::string> {
-    auto format(my_type my, format_context &ctx) const -> decltype(ctx.out()) {
-        return format_to(ctx.out(), "[my_type i={}]", my.i);
-    }
-};
-#endif
-
-void user_defined_example() { spdlog::info("user defined type: {}", my_type(14)); }
-
-// Custom error handler. Will be triggered on log failure.
-void err_handler_example() {
-    // can be set globally or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) {
-        printf("*** Custom log error handler: %s ***\n", msg.c_str());
-    });
-}
-
-// syslog example (linux/osx/freebsd)
-#ifndef _WIN32
-    #include "spdlog/sinks/syslog_sink.h"
-void syslog_example() {
-    std::string ident = "spdlog-example";
-    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
-    syslog_logger->warn("This is warning that will end up in syslog.");
-}
-#endif
-
-// Android example.
-#if defined(__ANDROID__)
-    #include "spdlog/sinks/android_sink.h"
-void android_example() {
-    std::string tag = "spdlog-android";
-    auto android_logger = spdlog::android_logger_mt("android", tag);
-    android_logger->critical("Use \"adb shell logcat\" to view this message.");
-}
-#endif
-
-// Log patterns can contain custom flags.
-// this will add custom flag '%*' which will be bound to a <my_formatter_flag> instance
-#include "spdlog/pattern_formatter.h"
-class my_formatter_flag : public spdlog::custom_flag_formatter {
-public:
-    void format(const spdlog::details::log_msg &,
-                const std::tm &,
-                spdlog::memory_buf_t &dest) override {
-        std::string some_txt = "custom-flag";
-        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
-    }
-
-    std::unique_ptr<custom_flag_formatter> clone() const override {
-        return spdlog::details::make_unique<my_formatter_flag>();
-    }
-};
-
-void custom_flags_example() {
-    using spdlog::details::make_unique;  // for pre c++14
-    auto formatter = make_unique<spdlog::pattern_formatter>();
-    formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
-    // set the new formatter using spdlog::set_formatter(formatter) or
-    // logger->set_formatter(formatter) spdlog::set_formatter(std::move(formatter));
-}
-
-void file_events_example() {
-    // pass the spdlog::file_event_handlers to file sinks for open/close log file notifications
-    spdlog::file_event_handlers handlers;
-    handlers.before_open = [](spdlog::filename_t filename) {
-        spdlog::info("Before opening {}", filename);
-    };
-    handlers.after_open = [](spdlog::filename_t filename, std::FILE *fstream) {
-        spdlog::info("After opening {}", filename);
-        fputs("After opening\n", fstream);
-    };
-    handlers.before_close = [](spdlog::filename_t filename, std::FILE *fstream) {
-        spdlog::info("Before closing {}", filename);
-        fputs("Before closing\n", fstream);
-    };
-    handlers.after_close = [](spdlog::filename_t filename) {
-        spdlog::info("After closing {}", filename);
-    };
-    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/events-sample.txt",
-                                                                         true, handlers);
-    spdlog::logger my_logger("some_logger", file_sink);
-    my_logger.info("Some log line");
-}
-
-void replace_default_logger_example() {
-    // store the old logger so we don't break other examples.
-    auto old_logger = spdlog::default_logger();
-
-    auto new_logger =
-        spdlog::basic_logger_mt("new_default_logger", "logs/new-default-log.txt", true);
-    spdlog::set_default_logger(new_logger);
-    spdlog::set_level(spdlog::level::info);
-    spdlog::debug("This message should not be displayed!");
-    spdlog::set_level(spdlog::level::trace);
-    spdlog::debug("This message should be displayed..");
-
-    spdlog::set_default_logger(old_logger);
-}
diff --git a/Dependencies/spdlog/include/spdlog/details/file_helper-inl.h b/Dependencies/spdlog/include/spdlog/details/file_helper-inl.h
index 97215f50..69af9b6a 100644
--- a/Dependencies/spdlog/include/spdlog/details/file_helper-inl.h
+++ b/Dependencies/spdlog/include/spdlog/details/file_helper-inl.h
@@ -98,6 +98,7 @@ SPDLOG_INLINE void file_helper::close() {
 }
 
 SPDLOG_INLINE void file_helper::write(const memory_buf_t &buf) {
+    if(fd_ == nullptr) return;
     size_t msg_size = buf.size();
     auto data = buf.data();
     if (std::fwrite(data, 1, msg_size, fd_) != msg_size) {
diff --git a/Dependencies/spdlog/include/spdlog/version.h b/Dependencies/spdlog/include/spdlog/version.h
index ab05e8dd..1ee5a9ff 100644
--- a/Dependencies/spdlog/include/spdlog/version.h
+++ b/Dependencies/spdlog/include/spdlog/version.h
@@ -4,7 +4,7 @@
 #pragma once
 
 #define SPDLOG_VER_MAJOR 1
-#define SPDLOG_VER_MINOR 12
+#define SPDLOG_VER_MINOR 13
 #define SPDLOG_VER_PATCH 0
 
 #define SPDLOG_TO_VERSION(major, minor, patch) (major * 10000 + minor * 100 + patch)
diff --git a/Dependencies/spdlog/logos/jetbrains-variant-4.svg b/Dependencies/spdlog/logos/jetbrains-variant-4.svg
deleted file mode 100644
index e02b5595..00000000
--- a/Dependencies/spdlog/logos/jetbrains-variant-4.svg
+++ /dev/null
@@ -1,43 +0,0 @@
-<svg id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="263" height="147" viewBox="0 0 263 147">
-  <defs>
-    <linearGradient id="linear-gradient" x1="54.4568" y1="122.5936" x2="251.779" y2="10.2057" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#00adee"/>
-      <stop offset="1" stop-color="#9f76a6"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-2" x1="80.247" y1="38.7607" x2="241.2622" y2="10.9511" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#ec037c"/>
-      <stop offset="1" stop-color="#9f76a6"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-3" x1="75.7205" y1="33.5582" x2="127.8253" y2="123.9392" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#ec037c"/>
-      <stop offset="1" stop-color="#5c2d90"/>
-    </linearGradient>
-    <linearGradient id="linear-gradient-4" x1="7.4647" y1="44.578" x2="129.4543" y2="125.0813" gradientUnits="userSpaceOnUse">
-      <stop offset="0" stop-color="#44c7f4"/>
-      <stop offset="1" stop-color="#5c2d90"/>
-    </linearGradient>
-  </defs>
-  <g>
-    <path d="M261.1839,10.3622a9.6784,9.6784,0,0,0-14.7448-8.2463l0-.0006L20.6942,136.0746h0a4.6974,4.6974,0,1,0,4.1326,8.4348h0q0.09-.0467.1784-0.097l230.5273-125.25a9.653,9.653,0,0,0,1.1508-.6253l0.0332-.018-0.0014-.0023A9.6682,9.6682,0,0,0,261.1839,10.3622Z" fill="url(#linear-gradient)"/>
-    <path d="M261.1839,10.3622A9.6782,9.6782,0,0,0,251.5057.684q-0.2747,0-.5456.0157-0.25.0143-.4975,0.041L76.7981,25.4187A13.7347,13.7347,0,1,0,83.5355,51.983L252.8044,19.9512a9.6363,9.6363,0,0,0,1.0358-.196l0.02-.0039,0-.0008A9.6811,9.6811,0,0,0,261.1839,10.3622Z" fill="url(#linear-gradient-2)"/>
-    <path d="M145.2028,123.63a17.2372,17.2372,0,0,0-3.0637-9.4254L91.3045,32.3521A13.7366,13.7366,0,0,0,66.1132,42.9507h0a13.6332,13.6332,0,0,0,1.043,2.4984s45.2334,86.37,45.5824,86.9979q0.3089,0.556.6567,1.0861h0A17.32,17.32,0,0,0,145.2028,123.63Z" fill="url(#linear-gradient-3)"/>
-    <path d="M145.2028,123.63a17.2979,17.2979,0,0,0-7.63-13.9419h0a17.3061,17.3061,0,0,0-2.6994-1.4911L9.5484,38.9679a6.064,6.064,0,0,0-6.5074,10.187l114.3963,88.704A17.3191,17.3191,0,0,0,145.2028,123.63Z" fill="url(#linear-gradient-4)"/>
-    <g>
-      <rect x="69" y="51" width="70" height="70"/>
-      <g>
-        <rect x="75.038" y="107.8746" width="26.2498" height="4.375" fill="#fff"/>
-        <g>
-          <path d="M74.7429,69.4315L76.78,67.5082a2.31,2.31,0,0,0,1.7929,1.0594A1.33,1.33,0,0,0,79.8607,66.97V59.75h3.1456v7.2366a4.2386,4.2386,0,0,1-1.1246,3.2108,4.2989,4.2989,0,0,1-3.1293,1.1572A4.6592,4.6592,0,0,1,74.7429,69.4315Z" fill="#fff"/>
-          <path d="M83.7394,59.75h9.1761v2.673H86.8688v1.744H92.345v2.4937H86.8688V68.47H92.997v2.6893H83.7394V59.75Z" fill="#fff"/>
-          <path d="M97.049,62.5208H93.6426V59.75h9.9911v2.7708h-3.4227v8.6383H97.049V62.5208Z" fill="#fff"/>
-          <path d="M75.0363,73.8257h5.8511A4.2728,4.2728,0,0,1,84,74.8363a2.5675,2.5675,0,0,1,.7335,1.858v0.0326a2.6407,2.6407,0,0,1-1.76,2.5425,2.7686,2.7686,0,0,1,2.2655,2.7871v0.0326c0,1.9558-1.5973,3.1456-4.3191,3.1456H75.0363V73.8257Zm6.5846,3.5206c0-.6357-0.5052-0.9779-1.4343-0.9779h-2.07v2.0047h1.9884c0.9616,0,1.5158-.326,1.5158-0.9942V77.3463ZM80.5289,80.59H78.1166v2.1025h2.4448c0.9779,0,1.5158-.3749,1.5158-1.0431V81.6165C82.0773,80.9972,81.5883,80.59,80.5289,80.59Z" fill="#fff"/>
-          <path d="M85.7116,73.8257h5.3949a5.0512,5.0512,0,0,1,3.7161,1.2224,3.5623,3.5623,0,0,1,1.01,2.6567v0.0326a3.6146,3.6146,0,0,1-2.3469,3.5205l2.7218,3.9769H92.5733l-2.2981-3.4553H88.8735v3.4553H85.7116V73.8257Zm5.2644,5.4764a1.433,1.433,0,0,0,1.6951-1.3528V77.9167c0-.9128-0.6682-1.3691-1.7114-1.3691H88.8735v2.7545H90.976Z" fill="#fff"/>
-          <path d="M99.5324,73.7443H102.58l4.8571,11.4905h-3.39l-0.815-2.0536H98.8153L98,85.2348H94.6917Zm2.7707,6.9758-1.2712-3.2271L99.7443,80.72h2.5589Z" fill="#fff"/>
-          <path d="M107.8117,73.8257h3.1619V85.2348h-3.1619V73.8257Z" fill="#fff"/>
-          <path d="M111.7558,73.8257h2.95l4.694,6.0306V73.8257h3.1294V85.2348h-2.7545l-4.89-6.2587v6.2587h-3.1293V73.8257Z" fill="#fff"/>
-          <path d="M122.7274,83.54l1.76-2.1025a5.9106,5.9106,0,0,0,3.7,1.3691c0.8638,0,1.32-.2934,1.32-0.7824V81.9914c0-.489-0.3749-0.7335-1.9395-1.1084-2.4285-.5541-4.3029-1.2387-4.3029-3.5694V77.2811c0-2.1188,1.6788-3.6509,4.417-3.6509a7.1807,7.1807,0,0,1,4.694,1.5158l-1.5809,2.2329a5.6006,5.6006,0,0,0-3.1946-1.1246c-0.766,0-1.1409.31-1.1409,0.7334V77.02c0,0.5216.3912,0.75,1.9884,1.1083,2.6077,0.57,4.2377,1.418,4.2377,3.5531v0.0326c0,2.3307-1.8418,3.7161-4.6126,3.7161A7.9992,7.9992,0,0,1,122.7274,83.54Z" fill="#fff"/>
-        </g>
-      </g>
-    </g>
-  </g>
-</svg>
diff --git a/Dependencies/spdlog/logos/spdlog.png b/Dependencies/spdlog/logos/spdlog.png
deleted file mode 100644
index 23014c85..00000000
Binary files a/Dependencies/spdlog/logos/spdlog.png and /dev/null differ
diff --git a/Dependencies/spdlog/scripts/ci_setup_clang.sh b/Dependencies/spdlog/scripts/ci_setup_clang.sh
deleted file mode 100644
index 140f9f9d..00000000
--- a/Dependencies/spdlog/scripts/ci_setup_clang.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-
-set -ex
-
-VERSION=$1
-
-apt-get update
-apt-get install -y libc++-${VERSION}-dev libc++abi-${VERSION}-dev
-
-if [[ "${VERSION}" -ge 12 ]]; then
-    apt-get install -y --no-install-recommends libunwind-${VERSION}-dev
-fi
diff --git a/Dependencies/spdlog/scripts/extract_version.py b/Dependencies/spdlog/scripts/extract_version.py
deleted file mode 100644
index 79b5728a..00000000
--- a/Dependencies/spdlog/scripts/extract_version.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-import re
-
-base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
-config_h = os.path.join(base_path, 'include', 'spdlog', 'version.h')
-data = {'MAJOR': 0, 'MINOR': 0, 'PATCH': 0}
-reg = re.compile(r'^\s*#define\s+SPDLOG_VER_([A-Z]+)\s+([0-9]+).*$')
-
-with open(config_h, 'r') as fp:
-    for l in fp:
-        m = reg.match(l)
-        if m:
-            data[m.group(1)] = int(m.group(2))
-
-print(f"{data['MAJOR']}.{data['MINOR']}.{data['PATCH']}")
diff --git a/Dependencies/spdlog/scripts/format.sh b/Dependencies/spdlog/scripts/format.sh
deleted file mode 100644
index 8eb01fb9..00000000
--- a/Dependencies/spdlog/scripts/format.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash
-
-cd "$(dirname "$0")"/..
-pwd
-find_sources="find include src tests example bench -not ( -path include/spdlog/fmt/bundled -prune ) -type f -name *\.h -o -name *\.cpp"
-echo -n "Running dos2unix     "
-$find_sources | xargs -I {} sh -c "dos2unix '{}' 2>/dev/null; echo -n '.'"
-echo
-echo -n "Running clang-format "
-
-$find_sources | xargs -I {} sh -c "clang-format -i {}; echo -n '.'"
-
-echo
-echo -n "Running cmake-format "
-find . -type f -name "CMakeLists.txt" -o -name "*\.cmake"|grep -v bundled|grep -v build|xargs -I {} sh -c "cmake-format --line-width 120 --tab-size 4 --max-subgroups-hwrap 4 -i {}; echo -n '.'"
-echo
-
-
-
diff --git a/Dependencies/spdlog/spdlog.lua b/Dependencies/spdlog/spdlog.lua
index a5d55a17..81c436a6 100644
--- a/Dependencies/spdlog/spdlog.lua
+++ b/Dependencies/spdlog/spdlog.lua
@@ -1,7 +1,7 @@
 local function SetupLib()
     local basePath = path.getabsolute("spdlog/", Engine.dependencyDir)
     local dependencies = { }
-    local defines = { "_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS", "_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS", "SPDLOG_COMPILED_LIB" }
+    local defines = { "_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS", "_SILENCE_ALL_MS_EXT_DEPRECATION_WARNINGS", "SPDLOG_COMPILED_LIB", "SPDLOG_USE_STD_FORMAT" }
 
     ProjectTemplate("Spdlog", "StaticLib", nil, Engine.binDir, dependencies, defines)
 
diff --git a/Dependencies/spdlog/tests/CMakeLists.txt b/Dependencies/spdlog/tests/CMakeLists.txt
deleted file mode 100644
index 8300887a..00000000
--- a/Dependencies/spdlog/tests/CMakeLists.txt
+++ /dev/null
@@ -1,90 +0,0 @@
-cmake_minimum_required(VERSION 3.11)
-project(spdlog_utests CXX)
-
-if(NOT TARGET spdlog)
-    # Stand-alone build
-    find_package(spdlog REQUIRED)
-endif()
-
-include(../cmake/utils.cmake)
-
-find_package(PkgConfig)
-if(PkgConfig_FOUND)
-    pkg_check_modules(systemd libsystemd)
-endif()
-
-find_package(Catch2 3 QUIET)
-if(Catch2_FOUND)
-    message(STATUS "Packaged version of Catch will be used.")
-else()
-    message(STATUS "Bundled version of Catch will be downloaded and used.")
-    include(FetchContent)
-    FetchContent_Declare(Catch2
-            GIT_REPOSITORY https://github.com/catchorg/Catch2.git
-            GIT_TAG 53d0d913a422d356b23dd927547febdf69ee9081 # v3.5.0
-    )
-    FetchContent_MakeAvailable(Catch2)
-endif()
-
-set(SPDLOG_UTESTS_SOURCES
-    test_file_helper.cpp
-    test_file_logging.cpp
-    test_daily_logger.cpp
-    test_misc.cpp
-    test_eventlog.cpp
-    test_pattern_formatter.cpp
-    test_async.cpp
-    test_registry.cpp
-    test_macros.cpp
-    utils.cpp
-    main.cpp
-    test_mpmc_q.cpp
-    test_dup_filter.cpp
-    test_fmt_helper.cpp
-    test_stdout_api.cpp
-    test_backtrace.cpp
-    test_create_dir.cpp
-    test_custom_callbacks.cpp
-    test_cfg.cpp
-    test_time_point.cpp
-    test_stopwatch.cpp
-    test_circular_q.cpp)
-
-if(NOT SPDLOG_NO_EXCEPTIONS)
-    list(APPEND SPDLOG_UTESTS_SOURCES test_errors.cpp)
-endif()
-
-if(systemd_FOUND)
-    list(APPEND SPDLOG_UTESTS_SOURCES test_systemd.cpp)
-endif()
-
-if(NOT SPDLOG_USE_STD_FORMAT)
-    list(APPEND SPDLOG_UTESTS_SOURCES test_bin_to_hex.cpp)
-endif()
-
-enable_testing()
-
-function(spdlog_prepare_test test_target spdlog_lib)
-    add_executable(${test_target} ${SPDLOG_UTESTS_SOURCES})
-    spdlog_enable_warnings(${test_target})
-    target_link_libraries(${test_target} PRIVATE ${spdlog_lib})
-    if(systemd_FOUND)
-        target_link_libraries(${test_target} PRIVATE ${systemd_LIBRARIES})
-    endif()
-    target_link_libraries(${test_target} PRIVATE Catch2::Catch2WithMain)
-    if(SPDLOG_SANITIZE_ADDRESS)
-        spdlog_enable_sanitizer(${test_target})
-    endif()
-    add_test(NAME ${test_target} COMMAND ${test_target})
-    set_tests_properties(${test_target} PROPERTIES RUN_SERIAL ON)
-endfunction()
-
-# The compiled library tests
-if(SPDLOG_BUILD_TESTS OR SPDLOG_BUILD_ALL)
-    spdlog_prepare_test(spdlog-utests spdlog::spdlog)
-endif()
-
-# The header-only library version tests
-if(SPDLOG_BUILD_TESTS_HO OR SPDLOG_BUILD_ALL)
-    spdlog_prepare_test(spdlog-utests-ho spdlog::spdlog_header_only)
-endif()
diff --git a/Dependencies/spdlog/tests/includes.h b/Dependencies/spdlog/tests/includes.h
deleted file mode 100644
index 8514d642..00000000
--- a/Dependencies/spdlog/tests/includes.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-
-#if defined(__GNUC__) && __GNUC__ == 12
-    #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"  // Workaround for GCC 12
-#endif
-#include <catch2/catch_all.hpp>
-#if defined(__GNUC__) && __GNUC__ == 12
-    #pragma GCC diagnostic pop
-#endif
-
-#include "utils.h"
-#include <chrono>
-#include <cstdio>
-#include <exception>
-#include <fstream>
-#include <iostream>
-#include <ostream>
-#include <sstream>
-#include <string>
-#include <iomanip>
-#include <stdlib.h>
-
-#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
-
-#include "spdlog/spdlog.h"
-#include "spdlog/async.h"
-#include "spdlog/details/fmt_helper.h"
-#include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/sinks/daily_file_sink.h"
-#include "spdlog/sinks/null_sink.h"
-#include "spdlog/sinks/ostream_sink.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-#include "spdlog/sinks/stdout_color_sinks.h"
-#include "spdlog/sinks/msvc_sink.h"
-#include "spdlog/pattern_formatter.h"
diff --git a/Dependencies/spdlog/tests/main.cpp b/Dependencies/spdlog/tests/main.cpp
deleted file mode 100644
index a4a4ff15..00000000
--- a/Dependencies/spdlog/tests/main.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#if defined(__GNUC__) && __GNUC__ == 12
-    #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"  // Workaround for GCC 12
-#endif
-
-#include <catch2/catch_all.hpp>
-
-#if defined(__GNUC__) && __GNUC__ == 12
-    #pragma GCC diagnostic pop
-#endif
diff --git a/Dependencies/spdlog/tests/test_async.cpp b/Dependencies/spdlog/tests/test_async.cpp
deleted file mode 100644
index 76fdd7c6..00000000
--- a/Dependencies/spdlog/tests/test_async.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-#include "includes.h"
-#include "spdlog/async.h"
-#include "spdlog/sinks/basic_file_sink.h"
-#include "test_sink.h"
-
-#define TEST_FILENAME "test_logs/async_test.log"
-
-TEST_CASE("basic async test ", "[async]") {
-    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
-    size_t overrun_counter = 0;
-    size_t queue_size = 128;
-    size_t messages = 256;
-    {
-        auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
-        auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp,
-                                                             spdlog::async_overflow_policy::block);
-        for (size_t i = 0; i < messages; i++) {
-            logger->info("Hello message #{}", i);
-        }
-        logger->flush();
-        overrun_counter = tp->overrun_counter();
-    }
-    REQUIRE(test_sink->msg_counter() == messages);
-    REQUIRE(test_sink->flush_counter() == 1);
-    REQUIRE(overrun_counter == 0);
-}
-
-TEST_CASE("discard policy ", "[async]") {
-    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
-    test_sink->set_delay(std::chrono::milliseconds(1));
-    size_t queue_size = 4;
-    size_t messages = 1024;
-
-    auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
-    auto logger = std::make_shared<spdlog::async_logger>(
-        "as", test_sink, tp, spdlog::async_overflow_policy::overrun_oldest);
-    for (size_t i = 0; i < messages; i++) {
-        logger->info("Hello message");
-    }
-    REQUIRE(test_sink->msg_counter() < messages);
-    REQUIRE(tp->overrun_counter() > 0);
-}
-
-TEST_CASE("discard policy discard_new ", "[async]") {
-    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
-    test_sink->set_delay(std::chrono::milliseconds(1));
-    size_t queue_size = 4;
-    size_t messages = 1024;
-
-    auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
-    auto logger = std::make_shared<spdlog::async_logger>(
-        "as", test_sink, tp, spdlog::async_overflow_policy::discard_new);
-    for (size_t i = 0; i < messages; i++) {
-        logger->info("Hello message");
-    }
-    REQUIRE(test_sink->msg_counter() < messages);
-    REQUIRE(tp->discard_counter() > 0);
-}
-
-TEST_CASE("discard policy using factory ", "[async]") {
-    size_t queue_size = 4;
-    size_t messages = 1024;
-    spdlog::init_thread_pool(queue_size, 1);
-
-    auto logger = spdlog::create_async_nb<spdlog::sinks::test_sink_mt>("as2");
-    auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]);
-    test_sink->set_delay(std::chrono::milliseconds(3));
-
-    for (size_t i = 0; i < messages; i++) {
-        logger->info("Hello message");
-    }
-
-    REQUIRE(test_sink->msg_counter() < messages);
-    spdlog::drop_all();
-}
-
-TEST_CASE("flush", "[async]") {
-    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
-    size_t queue_size = 256;
-    size_t messages = 256;
-    {
-        auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
-        auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp,
-                                                             spdlog::async_overflow_policy::block);
-        for (size_t i = 0; i < messages; i++) {
-            logger->info("Hello message #{}", i);
-        }
-
-        logger->flush();
-    }
-    // std::this_thread::sleep_for(std::chrono::milliseconds(250));
-    REQUIRE(test_sink->msg_counter() == messages);
-    REQUIRE(test_sink->flush_counter() == 1);
-}
-
-TEST_CASE("async periodic flush", "[async]") {
-    auto logger = spdlog::create_async<spdlog::sinks::test_sink_mt>("as");
-    auto test_sink = std::static_pointer_cast<spdlog::sinks::test_sink_mt>(logger->sinks()[0]);
-
-    spdlog::flush_every(std::chrono::seconds(1));
-    std::this_thread::sleep_for(std::chrono::milliseconds(1700));
-    REQUIRE(test_sink->flush_counter() == 1);
-    spdlog::flush_every(std::chrono::seconds(0));
-    spdlog::drop_all();
-}
-
-TEST_CASE("tp->wait_empty() ", "[async]") {
-    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
-    test_sink->set_delay(std::chrono::milliseconds(5));
-    size_t messages = 100;
-
-    auto tp = std::make_shared<spdlog::details::thread_pool>(messages, 2);
-    auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp,
-                                                         spdlog::async_overflow_policy::block);
-    for (size_t i = 0; i < messages; i++) {
-        logger->info("Hello message #{}", i);
-    }
-    logger->flush();
-    tp.reset();
-
-    REQUIRE(test_sink->msg_counter() == messages);
-    REQUIRE(test_sink->flush_counter() == 1);
-}
-
-TEST_CASE("multi threads", "[async]") {
-    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
-    size_t queue_size = 128;
-    size_t messages = 256;
-    size_t n_threads = 10;
-    {
-        auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
-        auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, tp,
-                                                             spdlog::async_overflow_policy::block);
-
-        std::vector<std::thread> threads;
-        for (size_t i = 0; i < n_threads; i++) {
-            threads.emplace_back([logger, messages] {
-                for (size_t j = 0; j < messages; j++) {
-                    logger->info("Hello message #{}", j);
-                }
-            });
-            logger->flush();
-        }
-
-        for (auto &t : threads) {
-            t.join();
-        }
-    }
-
-    REQUIRE(test_sink->msg_counter() == messages * n_threads);
-    REQUIRE(test_sink->flush_counter() == n_threads);
-}
-
-TEST_CASE("to_file", "[async]") {
-    prepare_logdir();
-    size_t messages = 1024;
-    size_t tp_threads = 1;
-    spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);
-    {
-        auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
-        auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads);
-        auto logger =
-            std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp));
-
-        for (size_t j = 0; j < messages; j++) {
-            logger->info("Hello message #{}", j);
-        }
-    }
-
-    require_message_count(TEST_FILENAME, messages);
-    auto contents = file_contents(TEST_FILENAME);
-    using spdlog::details::os::default_eol;
-    REQUIRE(ends_with(contents, spdlog::fmt_lib::format("Hello message #1023{}", default_eol)));
-}
-
-TEST_CASE("to_file multi-workers", "[async]") {
-    prepare_logdir();
-    size_t messages = 1024 * 10;
-    size_t tp_threads = 10;
-    spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);
-    {
-        auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
-        auto tp = std::make_shared<spdlog::details::thread_pool>(messages, tp_threads);
-        auto logger =
-            std::make_shared<spdlog::async_logger>("as", std::move(file_sink), std::move(tp));
-
-        for (size_t j = 0; j < messages; j++) {
-            logger->info("Hello message #{}", j);
-        }
-    }
-    require_message_count(TEST_FILENAME, messages);
-}
-
-TEST_CASE("bad_tp", "[async]") {
-    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
-    std::shared_ptr<spdlog::details::thread_pool> const empty_tp;
-    auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, empty_tp);
-    logger->info("Please throw an exception");
-    REQUIRE(test_sink->msg_counter() == 0);
-}
diff --git a/Dependencies/spdlog/tests/test_backtrace.cpp b/Dependencies/spdlog/tests/test_backtrace.cpp
deleted file mode 100644
index 4d78c0c2..00000000
--- a/Dependencies/spdlog/tests/test_backtrace.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#include "includes.h"
-#include "test_sink.h"
-#include "spdlog/async.h"
-
-TEST_CASE("bactrace1", "[bactrace]") {
-    using spdlog::sinks::test_sink_st;
-    auto test_sink = std::make_shared<test_sink_st>();
-    size_t backtrace_size = 5;
-
-    spdlog::logger logger("test-backtrace", test_sink);
-    logger.set_pattern("%v");
-    logger.enable_backtrace(backtrace_size);
-
-    logger.info("info message");
-    for (int i = 0; i < 100; i++) logger.debug("debug message {}", i);
-
-    REQUIRE(test_sink->lines().size() == 1);
-    REQUIRE(test_sink->lines()[0] == "info message");
-
-    logger.dump_backtrace();
-    REQUIRE(test_sink->lines().size() == backtrace_size + 3);
-    REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************");
-    REQUIRE(test_sink->lines()[2] == "debug message 95");
-    REQUIRE(test_sink->lines()[3] == "debug message 96");
-    REQUIRE(test_sink->lines()[4] == "debug message 97");
-    REQUIRE(test_sink->lines()[5] == "debug message 98");
-    REQUIRE(test_sink->lines()[6] == "debug message 99");
-    REQUIRE(test_sink->lines()[7] == "****************** Backtrace End ********************");
-}
-
-TEST_CASE("bactrace-empty", "[bactrace]") {
-    using spdlog::sinks::test_sink_st;
-    auto test_sink = std::make_shared<test_sink_st>();
-    size_t backtrace_size = 5;
-
-    spdlog::logger logger("test-backtrace", test_sink);
-    logger.set_pattern("%v");
-    logger.enable_backtrace(backtrace_size);
-    logger.dump_backtrace();
-    REQUIRE(test_sink->lines().size() == 0);
-}
-
-TEST_CASE("bactrace-async", "[bactrace]") {
-    using spdlog::sinks::test_sink_mt;
-    auto test_sink = std::make_shared<test_sink_mt>();
-    using spdlog::details::os::sleep_for_millis;
-
-    size_t backtrace_size = 5;
-
-    spdlog::init_thread_pool(120, 1);
-    auto logger = std::make_shared<spdlog::async_logger>("test-bactrace-async", test_sink,
-                                                         spdlog::thread_pool());
-    logger->set_pattern("%v");
-    logger->enable_backtrace(backtrace_size);
-
-    logger->info("info message");
-    for (int i = 0; i < 100; i++) logger->debug("debug message {}", i);
-
-    sleep_for_millis(100);
-    REQUIRE(test_sink->lines().size() == 1);
-    REQUIRE(test_sink->lines()[0] == "info message");
-
-    logger->dump_backtrace();
-    sleep_for_millis(100);  //  give time for the async dump to complete
-    REQUIRE(test_sink->lines().size() == backtrace_size + 3);
-    REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************");
-    REQUIRE(test_sink->lines()[2] == "debug message 95");
-    REQUIRE(test_sink->lines()[3] == "debug message 96");
-    REQUIRE(test_sink->lines()[4] == "debug message 97");
-    REQUIRE(test_sink->lines()[5] == "debug message 98");
-    REQUIRE(test_sink->lines()[6] == "debug message 99");
-    REQUIRE(test_sink->lines()[7] == "****************** Backtrace End ********************");
-}
diff --git a/Dependencies/spdlog/tests/test_bin_to_hex.cpp b/Dependencies/spdlog/tests/test_bin_to_hex.cpp
deleted file mode 100644
index 45fc9fa9..00000000
--- a/Dependencies/spdlog/tests/test_bin_to_hex.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-#include "includes.h"
-#include "test_sink.h"
-#include "spdlog/fmt/bin_to_hex.h"
-
-TEST_CASE("to_hex", "[to_hex]") {
-    std::ostringstream oss;
-    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
-    spdlog::logger oss_logger("oss", oss_sink);
-
-    std::vector<unsigned char> v{9, 0xa, 0xb, 0xc, 0xff, 0xff};
-    oss_logger.info("{}", spdlog::to_hex(v));
-
-    auto output = oss.str();
-    REQUIRE(ends_with(output,
-                      "0000: 09 0a 0b 0c ff ff" + std::string(spdlog::details::os::default_eol)));
-}
-
-TEST_CASE("to_hex_upper", "[to_hex]") {
-    std::ostringstream oss;
-    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
-    spdlog::logger oss_logger("oss", oss_sink);
-
-    std::vector<unsigned char> v{9, 0xa, 0xb, 0xc, 0xff, 0xff};
-    oss_logger.info("{:X}", spdlog::to_hex(v));
-
-    auto output = oss.str();
-    REQUIRE(ends_with(output,
-                      "0000: 09 0A 0B 0C FF FF" + std::string(spdlog::details::os::default_eol)));
-}
-
-TEST_CASE("to_hex_no_delimiter", "[to_hex]") {
-    std::ostringstream oss;
-    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
-    spdlog::logger oss_logger("oss", oss_sink);
-
-    std::vector<unsigned char> v{9, 0xa, 0xb, 0xc, 0xff, 0xff};
-    oss_logger.info("{:sX}", spdlog::to_hex(v));
-
-    auto output = oss.str();
-    REQUIRE(
-        ends_with(output, "0000: 090A0B0CFFFF" + std::string(spdlog::details::os::default_eol)));
-}
-
-TEST_CASE("to_hex_show_ascii", "[to_hex]") {
-    std::ostringstream oss;
-    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
-    spdlog::logger oss_logger("oss", oss_sink);
-
-    std::vector<unsigned char> v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff};
-    oss_logger.info("{:Xsa}", spdlog::to_hex(v, 8));
-
-    REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4BFFFF  ...A.K.." +
-                                     std::string(spdlog::details::os::default_eol)));
-}
-
-TEST_CASE("to_hex_different_size_per_line", "[to_hex]") {
-    std::ostringstream oss;
-    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
-    spdlog::logger oss_logger("oss", oss_sink);
-
-    std::vector<unsigned char> v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff};
-
-    oss_logger.info("{:Xsa}", spdlog::to_hex(v, 10));
-    REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4BFFFF  ...A.K.." +
-                                     std::string(spdlog::details::os::default_eol)));
-
-    oss_logger.info("{:Xs}", spdlog::to_hex(v, 10));
-    REQUIRE(ends_with(oss.str(),
-                      "0000: 090A0B410C4BFFFF" + std::string(spdlog::details::os::default_eol)));
-
-    oss_logger.info("{:Xsa}", spdlog::to_hex(v, 6));
-    REQUIRE(ends_with(
-        oss.str(), "0000: 090A0B410C4B  ...A.K" + std::string(spdlog::details::os::default_eol) +
-                       "0006: FFFF          .." + std::string(spdlog::details::os::default_eol)));
-
-    oss_logger.info("{:Xs}", spdlog::to_hex(v, 6));
-    REQUIRE(ends_with(oss.str(), "0000: 090A0B410C4B" +
-                                     std::string(spdlog::details::os::default_eol) + "0006: FFFF" +
-                                     std::string(spdlog::details::os::default_eol)));
-}
-
-TEST_CASE("to_hex_no_ascii", "[to_hex]") {
-    std::ostringstream oss;
-    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
-    spdlog::logger oss_logger("oss", oss_sink);
-
-    std::vector<unsigned char> v{9, 0xa, 0xb, 0x41, 0xc, 0x4b, 0xff, 0xff};
-    oss_logger.info("{:Xs}", spdlog::to_hex(v, 8));
-
-    REQUIRE(ends_with(oss.str(),
-                      "0000: 090A0B410C4BFFFF" + std::string(spdlog::details::os::default_eol)));
-
-    oss_logger.info("{:Xsna}", spdlog::to_hex(v, 8));
-
-    REQUIRE(
-        ends_with(oss.str(), "090A0B410C4BFFFF" + std::string(spdlog::details::os::default_eol)));
-}
diff --git a/Dependencies/spdlog/tests/test_cfg.cpp b/Dependencies/spdlog/tests/test_cfg.cpp
deleted file mode 100644
index 684d870c..00000000
--- a/Dependencies/spdlog/tests/test_cfg.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-
-#include "includes.h"
-#include "test_sink.h"
-
-#include <spdlog/cfg/env.h>
-#include <spdlog/cfg/argv.h>
-
-using spdlog::cfg::load_argv_levels;
-using spdlog::cfg::load_env_levels;
-using spdlog::sinks::test_sink_st;
-
-TEST_CASE("env", "[cfg]") {
-    spdlog::drop("l1");
-    auto l1 = spdlog::create<test_sink_st>("l1");
-#ifdef CATCH_PLATFORM_WINDOWS
-    _putenv_s("SPDLOG_LEVEL", "l1=warn");
-#else
-    setenv("SPDLOG_LEVEL", "l1=warn", 1);
-#endif
-    load_env_levels();
-    REQUIRE(l1->level() == spdlog::level::warn);
-    spdlog::set_default_logger(spdlog::create<test_sink_st>("cfg-default"));
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
-}
-
-TEST_CASE("argv1", "[cfg]") {
-    spdlog::drop("l1");
-    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=warn"};
-    load_argv_levels(2, argv);
-    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
-    REQUIRE(l1->level() == spdlog::level::warn);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
-}
-
-TEST_CASE("argv2", "[cfg]") {
-    spdlog::drop("l1");
-    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=warn,trace"};
-    load_argv_levels(2, argv);
-    auto l1 = spdlog::create<test_sink_st>("l1");
-    REQUIRE(l1->level() == spdlog::level::warn);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace);
-}
-
-TEST_CASE("argv3", "[cfg]") {
-    spdlog::set_level(spdlog::level::trace);
-
-    spdlog::drop("l1");
-    const char *argv[] = {"ignore", "SPDLOG_LEVEL=junk_name=warn"};
-    load_argv_levels(2, argv);
-    auto l1 = spdlog::create<test_sink_st>("l1");
-    REQUIRE(l1->level() == spdlog::level::trace);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace);
-}
-
-TEST_CASE("argv4", "[cfg]") {
-    spdlog::set_level(spdlog::level::info);
-    spdlog::drop("l1");
-    const char *argv[] = {"ignore", "SPDLOG_LEVEL=junk"};
-    load_argv_levels(2, argv);
-    auto l1 = spdlog::create<test_sink_st>("l1");
-    REQUIRE(l1->level() == spdlog::level::info);
-}
-
-TEST_CASE("argv5", "[cfg]") {
-    spdlog::set_level(spdlog::level::info);
-    spdlog::drop("l1");
-    const char *argv[] = {"ignore", "ignore", "SPDLOG_LEVEL=l1=warn,trace"};
-    load_argv_levels(3, argv);
-    auto l1 = spdlog::create<test_sink_st>("l1");
-    REQUIRE(l1->level() == spdlog::level::warn);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::trace);
-    spdlog::set_level(spdlog::level::info);
-}
-
-TEST_CASE("argv6", "[cfg]") {
-    spdlog::set_level(spdlog::level::err);
-    const char *argv[] = {""};
-    load_argv_levels(1, argv);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::err);
-    spdlog::set_level(spdlog::level::info);
-}
-
-TEST_CASE("argv7", "[cfg]") {
-    spdlog::set_level(spdlog::level::err);
-    const char *argv[] = {""};
-    load_argv_levels(0, argv);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::err);
-    spdlog::set_level(spdlog::level::info);
-}
-
-TEST_CASE("level-not-set-test1", "[cfg]") {
-    spdlog::drop("l1");
-    const char *argv[] = {"ignore", ""};
-    load_argv_levels(2, argv);
-    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
-    l1->set_level(spdlog::level::trace);
-    REQUIRE(l1->level() == spdlog::level::trace);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
-}
-
-TEST_CASE("level-not-set-test2", "[cfg]") {
-    spdlog::drop("l1");
-    spdlog::drop("l2");
-    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace"};
-
-    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
-    l1->set_level(spdlog::level::warn);
-    auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2");
-    l2->set_level(spdlog::level::warn);
-
-    load_argv_levels(2, argv);
-
-    REQUIRE(l1->level() == spdlog::level::trace);
-    REQUIRE(l2->level() == spdlog::level::warn);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
-}
-
-TEST_CASE("level-not-set-test3", "[cfg]") {
-    spdlog::drop("l1");
-    spdlog::drop("l2");
-    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace"};
-
-    load_argv_levels(2, argv);
-
-    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
-    auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2");
-
-    REQUIRE(l1->level() == spdlog::level::trace);
-    REQUIRE(l2->level() == spdlog::level::info);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
-}
-
-TEST_CASE("level-not-set-test4", "[cfg]") {
-    spdlog::drop("l1");
-    spdlog::drop("l2");
-    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=trace,warn"};
-
-    load_argv_levels(2, argv);
-
-    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
-    auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2");
-
-    REQUIRE(l1->level() == spdlog::level::trace);
-    REQUIRE(l2->level() == spdlog::level::warn);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn);
-}
-
-TEST_CASE("level-not-set-test5", "[cfg]") {
-    spdlog::drop("l1");
-    spdlog::drop("l2");
-    const char *argv[] = {"ignore", "SPDLOG_LEVEL=l1=junk,warn"};
-
-    load_argv_levels(2, argv);
-
-    auto l1 = spdlog::create<spdlog::sinks::test_sink_st>("l1");
-    auto l2 = spdlog::create<spdlog::sinks::test_sink_st>("l2");
-
-    REQUIRE(l1->level() == spdlog::level::warn);
-    REQUIRE(l2->level() == spdlog::level::warn);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::warn);
-}
-
-TEST_CASE("restore-to-default", "[cfg]") {
-    spdlog::drop("l1");
-    spdlog::drop("l2");
-    const char *argv[] = {"ignore", "SPDLOG_LEVEL=info"};
-    load_argv_levels(2, argv);
-    REQUIRE(spdlog::default_logger()->level() == spdlog::level::info);
-}
diff --git a/Dependencies/spdlog/tests/test_circular_q.cpp b/Dependencies/spdlog/tests/test_circular_q.cpp
deleted file mode 100644
index c8b02d36..00000000
--- a/Dependencies/spdlog/tests/test_circular_q.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "includes.h"
-#include "spdlog/details/circular_q.h"
-
-using q_type = spdlog::details::circular_q<size_t>;
-TEST_CASE("test_size", "[circular_q]") {
-    const size_t q_size = 4;
-    q_type q(q_size);
-    REQUIRE(q.size() == 0);
-    REQUIRE(q.empty() == true);
-    for (size_t i = 0; i < q_size; i++) {
-        q.push_back(std::move(i));
-    }
-    REQUIRE(q.size() == q_size);
-    q.push_back(999);
-    REQUIRE(q.size() == q_size);
-}
-
-TEST_CASE("test_rolling", "[circular_q]") {
-    const size_t q_size = 4;
-    q_type q(q_size);
-
-    for (size_t i = 0; i < q_size + 2; i++) {
-        q.push_back(std::move(i));
-    }
-
-    REQUIRE(q.size() == q_size);
-
-    REQUIRE(q.front() == 2);
-    q.pop_front();
-
-    REQUIRE(q.front() == 3);
-    q.pop_front();
-
-    REQUIRE(q.front() == 4);
-    q.pop_front();
-
-    REQUIRE(q.front() == 5);
-    q.pop_front();
-
-    REQUIRE(q.empty());
-
-    q.push_back(6);
-    REQUIRE(q.front() == 6);
-}
-
-TEST_CASE("test_empty", "[circular_q]") {
-    q_type q(0);
-    q.push_back(1);
-    REQUIRE(q.empty());
-}
\ No newline at end of file
diff --git a/Dependencies/spdlog/tests/test_create_dir.cpp b/Dependencies/spdlog/tests/test_create_dir.cpp
deleted file mode 100644
index f88825b0..00000000
--- a/Dependencies/spdlog/tests/test_create_dir.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * This content is released under the MIT License as specified in
- * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
- */
-#include "includes.h"
-
-using spdlog::details::os::create_dir;
-using spdlog::details::os::path_exists;
-
-bool try_create_dir(const spdlog::filename_t &path, const spdlog::filename_t &normalized_path) {
-    auto rv = create_dir(path);
-    REQUIRE(rv == true);
-    return path_exists(normalized_path);
-}
-
-TEST_CASE("create_dir", "[create_dir]") {
-    prepare_logdir();
-
-    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"),
-                           SPDLOG_FILENAME_T("test_logs/dir1/dir1")));
-    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1/dir1"),
-                           SPDLOG_FILENAME_T("test_logs/dir1/dir1")));  // test existing
-    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/dir1///dir2//"),
-                           SPDLOG_FILENAME_T("test_logs/dir1/dir2")));
-    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("./test_logs/dir1/dir3"),
-                           SPDLOG_FILENAME_T("test_logs/dir1/dir3")));
-    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs/../test_logs/dir1/dir4"),
-                           SPDLOG_FILENAME_T("test_logs/dir1/dir4")));
-
-#ifdef WIN32
-    // test backslash folder separator
-    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs\\dir1\\dir222"),
-                           SPDLOG_FILENAME_T("test_logs\\dir1\\dir222")));
-    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs\\dir1\\dir223\\"),
-                           SPDLOG_FILENAME_T("test_logs\\dir1\\dir223\\")));
-    REQUIRE(try_create_dir(SPDLOG_FILENAME_T(".\\test_logs\\dir1\\dir2\\dir99\\..\\dir23"),
-                           SPDLOG_FILENAME_T("test_logs\\dir1\\dir2\\dir23")));
-    REQUIRE(try_create_dir(SPDLOG_FILENAME_T("test_logs\\..\\test_logs\\dir1\\dir5"),
-                           SPDLOG_FILENAME_T("test_logs\\dir1\\dir5")));
-#endif
-}
-
-TEST_CASE("create_invalid_dir", "[create_dir]") {
-    REQUIRE(create_dir(SPDLOG_FILENAME_T("")) == false);
-    REQUIRE(create_dir(spdlog::filename_t{}) == false);
-#ifdef __linux__
-    REQUIRE(create_dir("/proc/spdlog-utest") == false);
-#endif
-}
-
-TEST_CASE("dir_name", "[create_dir]") {
-    using spdlog::details::os::dir_name;
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("")).empty());
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir")).empty());
-
-#ifdef WIN32
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\)")) == SPDLOG_FILENAME_T("dir"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\\\)")) == SPDLOG_FILENAME_T(R"(dir\\)"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\file)")) == SPDLOG_FILENAME_T("dir"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir/file)")) == SPDLOG_FILENAME_T("dir"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\file.txt)")) == SPDLOG_FILENAME_T("dir"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir/file)")) == SPDLOG_FILENAME_T("dir"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(dir\file.txt\)")) ==
-            SPDLOG_FILENAME_T(R"(dir\file.txt)"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(\dir\file.txt)")) == SPDLOG_FILENAME_T(R"(\dir)"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(\\dir\file.txt)")) == SPDLOG_FILENAME_T(R"(\\dir)"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(..\file.txt)")) == SPDLOG_FILENAME_T(".."));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(.\file.txt)")) == SPDLOG_FILENAME_T("."));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(c:\\a\b\c\d\file.txt)")) ==
-            SPDLOG_FILENAME_T(R"(c:\\a\b\c\d)"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T(R"(c://a/b/c/d/file.txt)")) ==
-            SPDLOG_FILENAME_T(R"(c://a/b/c/d)"));
-#endif
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/")) == SPDLOG_FILENAME_T("dir"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir///")) == SPDLOG_FILENAME_T("dir//"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/file")) == SPDLOG_FILENAME_T("dir"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/file.txt")) == SPDLOG_FILENAME_T("dir"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("dir/file.txt/")) == SPDLOG_FILENAME_T("dir/file.txt"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("/dir/file.txt")) == SPDLOG_FILENAME_T("/dir"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("//dir/file.txt")) == SPDLOG_FILENAME_T("//dir"));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("../file.txt")) == SPDLOG_FILENAME_T(".."));
-    REQUIRE(dir_name(SPDLOG_FILENAME_T("./file.txt")) == SPDLOG_FILENAME_T("."));
-}
diff --git a/Dependencies/spdlog/tests/test_custom_callbacks.cpp b/Dependencies/spdlog/tests/test_custom_callbacks.cpp
deleted file mode 100644
index 4b048572..00000000
--- a/Dependencies/spdlog/tests/test_custom_callbacks.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * This content is released under the MIT License as specified in
- * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
- */
-#include "includes.h"
-#include "test_sink.h"
-#include "spdlog/sinks/callback_sink.h"
-#include "spdlog/async.h"
-#include "spdlog/common.h"
-
-TEST_CASE("custom_callback_logger", "[custom_callback_logger]") {
-    std::vector<std::string> lines;
-    spdlog::pattern_formatter formatter;
-    auto callback_logger =
-        std::make_shared<spdlog::sinks::callback_sink_st>([&](const spdlog::details::log_msg &msg) {
-            spdlog::memory_buf_t formatted;
-            formatter.format(msg, formatted);
-            auto eol_len = strlen(spdlog::details::os::default_eol);
-            lines.emplace_back(formatted.begin(), formatted.end() - eol_len);
-        });
-    std::shared_ptr<spdlog::sinks::test_sink_st> test_sink(new spdlog::sinks::test_sink_st);
-
-    spdlog::logger logger("test-callback", {callback_logger, test_sink});
-
-    logger.info("test message 1");
-    logger.info("test message 2");
-    logger.info("test message 3");
-
-    std::vector<std::string> ref_lines = test_sink->lines();
-
-    REQUIRE(lines[0] == ref_lines[0]);
-    REQUIRE(lines[1] == ref_lines[1]);
-    REQUIRE(lines[2] == ref_lines[2]);
-    spdlog::drop_all();
-}
diff --git a/Dependencies/spdlog/tests/test_daily_logger.cpp b/Dependencies/spdlog/tests/test_daily_logger.cpp
deleted file mode 100644
index fe4783cb..00000000
--- a/Dependencies/spdlog/tests/test_daily_logger.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- * This content is released under the MIT License as specified in
- * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
- */
-#include "includes.h"
-
-#ifdef SPDLOG_USE_STD_FORMAT
-using filename_memory_buf_t = std::basic_string<spdlog::filename_t::value_type>;
-#else
-using filename_memory_buf_t = fmt::basic_memory_buffer<spdlog::filename_t::value_type, 250>;
-#endif
-
-#ifdef SPDLOG_WCHAR_FILENAMES
-std::string filename_buf_to_utf8string(const filename_memory_buf_t &w) {
-    spdlog::memory_buf_t buf;
-    spdlog::details::os::wstr_to_utf8buf(spdlog::wstring_view_t(w.data(), w.size()), buf);
-    return SPDLOG_BUF_TO_STRING(buf);
-}
-#else
-std::string filename_buf_to_utf8string(const filename_memory_buf_t &w) {
-    return SPDLOG_BUF_TO_STRING(w);
-}
-#endif
-
-TEST_CASE("daily_logger with dateonly calculator", "[daily_logger]") {
-    using sink_type =
-        spdlog::sinks::daily_file_sink<std::mutex, spdlog::sinks::daily_filename_calculator>;
-
-    prepare_logdir();
-
-    // calculate filename (time based)
-    spdlog::filename_t basename = SPDLOG_FILENAME_T("test_logs/daily_dateonly");
-    std::tm tm = spdlog::details::os::localtime();
-    filename_memory_buf_t w;
-    spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}"),
-                               basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
-
-    auto logger = spdlog::create<sink_type>("logger", basename, 0, 0);
-    for (int i = 0; i < 10; ++i) {
-        logger->info("Test message {}", i);
-    }
-    logger->flush();
-
-    require_message_count(filename_buf_to_utf8string(w), 10);
-}
-
-struct custom_daily_file_name_calculator {
-    static spdlog::filename_t calc_filename(const spdlog::filename_t &basename, const tm &now_tm) {
-        filename_memory_buf_t w;
-        spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"),
-                                   basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1,
-                                   now_tm.tm_mday);
-
-        return SPDLOG_BUF_TO_STRING(w);
-    }
-};
-
-TEST_CASE("daily_logger with custom calculator", "[daily_logger]") {
-    using sink_type = spdlog::sinks::daily_file_sink<std::mutex, custom_daily_file_name_calculator>;
-
-    prepare_logdir();
-
-    // calculate filename (time based)
-    spdlog::filename_t basename = SPDLOG_FILENAME_T("test_logs/daily_dateonly");
-    std::tm tm = spdlog::details::os::localtime();
-    filename_memory_buf_t w;
-    spdlog::fmt_lib::format_to(std::back_inserter(w), SPDLOG_FILENAME_T("{}{:04d}{:02d}{:02d}"),
-                               basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);
-
-    auto logger = spdlog::create<sink_type>("logger", basename, 0, 0);
-    for (int i = 0; i < 10; ++i) {
-        logger->info("Test message {}", i);
-    }
-
-    logger->flush();
-
-    require_message_count(filename_buf_to_utf8string(w), 10);
-}
-
-/*
- * File name calculations
- */
-
-TEST_CASE("rotating_file_sink::calc_filename1", "[rotating_file_sink]") {
-    auto filename =
-        spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T("rotated.txt"), 3);
-    REQUIRE(filename == SPDLOG_FILENAME_T("rotated.3.txt"));
-}
-
-TEST_CASE("rotating_file_sink::calc_filename2", "[rotating_file_sink]") {
-    auto filename =
-        spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T("rotated"), 3);
-    REQUIRE(filename == SPDLOG_FILENAME_T("rotated.3"));
-}
-
-TEST_CASE("rotating_file_sink::calc_filename3", "[rotating_file_sink]") {
-    auto filename =
-        spdlog::sinks::rotating_file_sink_st::calc_filename(SPDLOG_FILENAME_T("rotated.txt"), 0);
-    REQUIRE(filename == SPDLOG_FILENAME_T("rotated.txt"));
-}
-
-// regex supported only from gcc 4.9 and above
-#if defined(_MSC_VER) || !(__GNUC__ <= 4 && __GNUC_MINOR__ < 9)
-
-    #include <regex>
-
-TEST_CASE("daily_file_sink::daily_filename_calculator", "[daily_file_sink]") {
-    // daily_YYYY-MM-DD_hh-mm.txt
-    auto filename = spdlog::sinks::daily_filename_calculator::calc_filename(
-        SPDLOG_FILENAME_T("daily.txt"), spdlog::details::os::localtime());
-    // date regex based on https://www.regular-expressions.info/dates.html
-    std::basic_regex<spdlog::filename_t::value_type> re(
-        SPDLOG_FILENAME_T(R"(^daily_(19|20)\d\d-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])\.txt$)"));
-    std::match_results<spdlog::filename_t::const_iterator> match;
-    REQUIRE(std::regex_match(filename, match, re));
-}
-#endif
-
-TEST_CASE("daily_file_sink::daily_filename_format_calculator", "[daily_file_sink]") {
-    std::tm tm = spdlog::details::os::localtime();
-    // example-YYYY-MM-DD.log
-    auto filename = spdlog::sinks::daily_filename_format_calculator::calc_filename(
-        SPDLOG_FILENAME_T("example-%Y-%m-%d.log"), tm);
-
-    REQUIRE(filename ==
-            spdlog::fmt_lib::format(SPDLOG_FILENAME_T("example-{:04d}-{:02d}-{:02d}.log"),
-                                    tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday));
-}
-
-/* Test removal of old files */
-static spdlog::details::log_msg create_msg(std::chrono::seconds offset) {
-    using spdlog::log_clock;
-    spdlog::details::log_msg msg{"test", spdlog::level::info, "Hello Message"};
-    msg.time = log_clock::now() + offset;
-    return msg;
-}
-
-static void test_rotate(int days_to_run, uint16_t max_days, uint16_t expected_n_files) {
-    using spdlog::log_clock;
-    using spdlog::details::log_msg;
-    using spdlog::sinks::daily_file_sink_st;
-
-    prepare_logdir();
-
-    spdlog::filename_t basename = SPDLOG_FILENAME_T("test_logs/daily_rotate.txt");
-    daily_file_sink_st sink{basename, 2, 30, true, max_days};
-
-    // simulate messages with 24 intervals
-
-    for (int i = 0; i < days_to_run; i++) {
-        auto offset = std::chrono::seconds{24 * 3600 * i};
-        sink.log(create_msg(offset));
-    }
-
-    REQUIRE(count_files("test_logs") == static_cast<size_t>(expected_n_files));
-}
-
-TEST_CASE("daily_logger rotate", "[daily_file_sink]") {
-    int days_to_run = 1;
-    test_rotate(days_to_run, 0, 1);
-    test_rotate(days_to_run, 1, 1);
-    test_rotate(days_to_run, 3, 1);
-    test_rotate(days_to_run, 10, 1);
-
-    days_to_run = 10;
-    test_rotate(days_to_run, 0, 10);
-    test_rotate(days_to_run, 1, 1);
-    test_rotate(days_to_run, 3, 3);
-    test_rotate(days_to_run, 9, 9);
-    test_rotate(days_to_run, 10, 10);
-    test_rotate(days_to_run, 11, 10);
-    test_rotate(days_to_run, 20, 10);
-}
diff --git a/Dependencies/spdlog/tests/test_dup_filter.cpp b/Dependencies/spdlog/tests/test_dup_filter.cpp
deleted file mode 100644
index 78e22be3..00000000
--- a/Dependencies/spdlog/tests/test_dup_filter.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include "includes.h"
-#include "spdlog/sinks/dup_filter_sink.h"
-#include "test_sink.h"
-
-TEST_CASE("dup_filter_test1", "[dup_filter_sink]") {
-    using spdlog::sinks::dup_filter_sink_st;
-    using spdlog::sinks::test_sink_mt;
-
-    dup_filter_sink_st dup_sink{std::chrono::seconds{5}};
-    auto test_sink = std::make_shared<test_sink_mt>();
-    dup_sink.add_sink(test_sink);
-
-    for (int i = 0; i < 10; i++) {
-        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
-    }
-
-    REQUIRE(test_sink->msg_counter() == 1);
-}
-
-TEST_CASE("dup_filter_test2", "[dup_filter_sink]") {
-    using spdlog::sinks::dup_filter_sink_st;
-    using spdlog::sinks::test_sink_mt;
-
-    dup_filter_sink_st dup_sink{std::chrono::seconds{0}};
-    auto test_sink = std::make_shared<test_sink_mt>();
-    dup_sink.add_sink(test_sink);
-
-    for (int i = 0; i < 10; i++) {
-        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
-        std::this_thread::sleep_for(std::chrono::milliseconds(5));
-    }
-
-    REQUIRE(test_sink->msg_counter() == 10);
-}
-
-TEST_CASE("dup_filter_test3", "[dup_filter_sink]") {
-    using spdlog::sinks::dup_filter_sink_st;
-    using spdlog::sinks::test_sink_mt;
-
-    dup_filter_sink_st dup_sink{std::chrono::seconds{1}};
-    auto test_sink = std::make_shared<test_sink_mt>();
-    dup_sink.add_sink(test_sink);
-
-    for (int i = 0; i < 10; i++) {
-        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
-        dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"});
-    }
-
-    REQUIRE(test_sink->msg_counter() == 20);
-}
-
-TEST_CASE("dup_filter_test4", "[dup_filter_sink]") {
-    using spdlog::sinks::dup_filter_sink_mt;
-    using spdlog::sinks::test_sink_mt;
-
-    dup_filter_sink_mt dup_sink{std::chrono::milliseconds{10}};
-    auto test_sink = std::make_shared<test_sink_mt>();
-    dup_sink.add_sink(test_sink);
-
-    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message"});
-    std::this_thread::sleep_for(std::chrono::milliseconds(50));
-    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message"});
-    REQUIRE(test_sink->msg_counter() == 2);
-}
-
-TEST_CASE("dup_filter_test5", "[dup_filter_sink]") {
-    using spdlog::sinks::dup_filter_sink_mt;
-    using spdlog::sinks::test_sink_mt;
-
-    dup_filter_sink_mt dup_sink{std::chrono::seconds{5}};
-    auto test_sink = std::make_shared<test_sink_mt>();
-    test_sink->set_pattern("%v");
-    dup_sink.add_sink(test_sink);
-
-    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
-    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
-    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message1"});
-    dup_sink.log(spdlog::details::log_msg{"test", spdlog::level::info, "message2"});
-
-    REQUIRE(test_sink->msg_counter() ==
-            3);  // skip 2 messages but log the "skipped.." message before message2
-    REQUIRE(test_sink->lines()[1] == "Skipped 2 duplicate messages..");
-}
diff --git a/Dependencies/spdlog/tests/test_errors.cpp b/Dependencies/spdlog/tests/test_errors.cpp
deleted file mode 100644
index 7dde919d..00000000
--- a/Dependencies/spdlog/tests/test_errors.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * This content is released under the MIT License as specified in
- * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
- */
-#include "includes.h"
-
-#include <iostream>
-
-#define SIMPLE_LOG "test_logs/simple_log.txt"
-#define SIMPLE_ASYNC_LOG "test_logs/simple_async_log.txt"
-
-class failing_sink : public spdlog::sinks::base_sink<std::mutex> {
-protected:
-    void sink_it_(const spdlog::details::log_msg &) final {
-        throw std::runtime_error("some error happened during log");
-    }
-
-    void flush_() final { throw std::runtime_error("some error happened during flush"); }
-};
-struct custom_ex {};
-
-#if !defined(SPDLOG_USE_STD_FORMAT)  // std formt doesn't fully support tuntime strings
-TEST_CASE("default_error_handler", "[errors]") {
-    prepare_logdir();
-    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
-
-    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("test-error", filename, true);
-    logger->set_pattern("%v");
-    logger->info(SPDLOG_FMT_RUNTIME("Test message {} {}"), 1);
-    logger->info("Test message {}", 2);
-    logger->flush();
-    using spdlog::details::os::default_eol;
-    REQUIRE(file_contents(SIMPLE_LOG) == spdlog::fmt_lib::format("Test message 2{}", default_eol));
-    REQUIRE(count_lines(SIMPLE_LOG) == 1);
-}
-
-TEST_CASE("custom_error_handler", "[errors]") {
-    prepare_logdir();
-    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
-    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename, true);
-    logger->flush_on(spdlog::level::info);
-    logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
-    logger->info("Good message #1");
-
-    REQUIRE_THROWS_AS(logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx"), custom_ex);
-    logger->info("Good message #2");
-    require_message_count(SIMPLE_LOG, 2);
-}
-#endif
-
-TEST_CASE("default_error_handler2", "[errors]") {
-    spdlog::drop_all();
-    auto logger = spdlog::create<failing_sink>("failed_logger");
-    logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
-    REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex);
-}
-
-TEST_CASE("flush_error_handler", "[errors]") {
-    spdlog::drop_all();
-    auto logger = spdlog::create<failing_sink>("failed_logger");
-    logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
-    REQUIRE_THROWS_AS(logger->flush(), custom_ex);
-}
-
-#if !defined(SPDLOG_USE_STD_FORMAT)
-TEST_CASE("async_error_handler", "[errors]") {
-    prepare_logdir();
-    std::string err_msg("log failed with some msg");
-
-    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_ASYNC_LOG);
-    {
-        spdlog::init_thread_pool(128, 1);
-        auto logger =
-            spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("logger", filename, true);
-        logger->set_error_handler([=](const std::string &) {
-            std::ofstream ofs("test_logs/custom_err.txt");
-            if (!ofs) {
-                throw std::runtime_error("Failed open test_logs/custom_err.txt");
-            }
-            ofs << err_msg;
-        });
-        logger->info("Good message #1");
-        logger->info(SPDLOG_FMT_RUNTIME("Bad format msg {} {}"), "xxx");
-        logger->info("Good message #2");
-        spdlog::drop("logger");  // force logger to drain the queue and shutdown
-    }
-    spdlog::init_thread_pool(128, 1);
-    require_message_count(SIMPLE_ASYNC_LOG, 2);
-    REQUIRE(file_contents("test_logs/custom_err.txt") == err_msg);
-}
-#endif
-
-// Make sure async error handler is executed
-TEST_CASE("async_error_handler2", "[errors]") {
-    prepare_logdir();
-    std::string err_msg("This is async handler error message");
-    {
-        spdlog::details::os::create_dir(SPDLOG_FILENAME_T("test_logs"));
-        spdlog::init_thread_pool(128, 1);
-        auto logger = spdlog::create_async<failing_sink>("failed_logger");
-        logger->set_error_handler([=](const std::string &) {
-            std::ofstream ofs("test_logs/custom_err2.txt");
-            if (!ofs) throw std::runtime_error("Failed open test_logs/custom_err2.txt");
-            ofs << err_msg;
-        });
-        logger->info("Hello failure");
-        spdlog::drop("failed_logger");  // force logger to drain the queue and shutdown
-    }
-
-    spdlog::init_thread_pool(128, 1);
-    REQUIRE(file_contents("test_logs/custom_err2.txt") == err_msg);
-}
diff --git a/Dependencies/spdlog/tests/test_eventlog.cpp b/Dependencies/spdlog/tests/test_eventlog.cpp
deleted file mode 100644
index 702eabea..00000000
--- a/Dependencies/spdlog/tests/test_eventlog.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#if _WIN32
-
-    #include "includes.h"
-    #include "test_sink.h"
-
-    #include "spdlog/sinks/win_eventlog_sink.h"
-
-static const LPCSTR TEST_SOURCE = "spdlog_test";
-
-static void test_single_print(std::function<void(std::string const &)> do_log,
-                              std::string const &expected_contents,
-                              WORD expected_ev_type) {
-    using namespace std::chrono;
-    do_log(expected_contents);
-    const auto expected_time_generated =
-        duration_cast<seconds>(system_clock::now().time_since_epoch()).count();
-
-    struct handle_t {
-        HANDLE handle_;
-
-        ~handle_t() {
-            if (handle_) {
-                REQUIRE(CloseEventLog(handle_));
-            }
-        }
-    } event_log{::OpenEventLogA(nullptr, TEST_SOURCE)};
-
-    REQUIRE(event_log.handle_);
-
-    DWORD read_bytes{}, size_needed{};
-    auto ok = ::ReadEventLogA(event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ,
-                              0, &read_bytes, 0, &read_bytes, &size_needed);
-    REQUIRE(!ok);
-    REQUIRE(::GetLastError() == ERROR_INSUFFICIENT_BUFFER);
-
-    std::vector<char> record_buffer(size_needed);
-    PEVENTLOGRECORD record = (PEVENTLOGRECORD)record_buffer.data();
-
-    ok = ::ReadEventLogA(event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 0,
-                         record, size_needed, &read_bytes, &size_needed);
-    REQUIRE(ok);
-
-    REQUIRE(record->NumStrings == 1);
-    REQUIRE(record->EventType == expected_ev_type);
-    REQUIRE((expected_time_generated - record->TimeGenerated) <= 3u);
-
-    std::string message_in_log(((char *)record + record->StringOffset));
-    REQUIRE(message_in_log == expected_contents + spdlog::details::os::default_eol);
-}
-
-TEST_CASE("eventlog", "[eventlog]") {
-    using namespace spdlog;
-
-    auto test_sink = std::make_shared<sinks::win_eventlog_sink_mt>(TEST_SOURCE);
-
-    spdlog::logger test_logger("eventlog", test_sink);
-    test_logger.set_level(level::trace);
-
-    test_sink->set_pattern("%v");
-
-    test_single_print([&test_logger](std::string const &msg) { test_logger.trace(msg); },
-                      "my trace message", EVENTLOG_SUCCESS);
-    test_single_print([&test_logger](std::string const &msg) { test_logger.debug(msg); },
-                      "my debug message", EVENTLOG_SUCCESS);
-    test_single_print([&test_logger](std::string const &msg) { test_logger.info(msg); },
-                      "my info message", EVENTLOG_INFORMATION_TYPE);
-    test_single_print([&test_logger](std::string const &msg) { test_logger.warn(msg); },
-                      "my warn message", EVENTLOG_WARNING_TYPE);
-    test_single_print([&test_logger](std::string const &msg) { test_logger.error(msg); },
-                      "my error message", EVENTLOG_ERROR_TYPE);
-    test_single_print([&test_logger](std::string const &msg) { test_logger.critical(msg); },
-                      "my critical message", EVENTLOG_ERROR_TYPE);
-}
-
-#endif  //_WIN32
diff --git a/Dependencies/spdlog/tests/test_file_helper.cpp b/Dependencies/spdlog/tests/test_file_helper.cpp
deleted file mode 100644
index de7d51d9..00000000
--- a/Dependencies/spdlog/tests/test_file_helper.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
- * This content is released under the MIT License as specified in
- * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
- */
-#include "includes.h"
-
-#define TEST_FILENAME "test_logs/file_helper_test.txt"
-
-using spdlog::details::file_helper;
-
-static void write_with_helper(file_helper &helper, size_t howmany) {
-    spdlog::memory_buf_t formatted;
-    spdlog::fmt_lib::format_to(std::back_inserter(formatted), "{}", std::string(howmany, '1'));
-    helper.write(formatted);
-    helper.flush();
-}
-
-TEST_CASE("file_helper_filename", "[file_helper::filename()]") {
-    prepare_logdir();
-
-    file_helper helper;
-    spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
-    helper.open(target_filename);
-    REQUIRE(helper.filename() == target_filename);
-}
-
-TEST_CASE("file_helper_size", "[file_helper::size()]") {
-    prepare_logdir();
-    spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
-    size_t expected_size = 123;
-    {
-        file_helper helper;
-        helper.open(target_filename);
-        write_with_helper(helper, expected_size);
-        REQUIRE(static_cast<size_t>(helper.size()) == expected_size);
-    }
-    REQUIRE(get_filesize(TEST_FILENAME) == expected_size);
-}
-
-TEST_CASE("file_helper_reopen", "[file_helper::reopen()]") {
-    prepare_logdir();
-    spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
-    file_helper helper;
-    helper.open(target_filename);
-    write_with_helper(helper, 12);
-    REQUIRE(helper.size() == 12);
-    helper.reopen(true);
-    REQUIRE(helper.size() == 0);
-}
-
-TEST_CASE("file_helper_reopen2", "[file_helper::reopen(false)]") {
-    prepare_logdir();
-    spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
-    size_t expected_size = 14;
-    file_helper helper;
-    helper.open(target_filename);
-    write_with_helper(helper, expected_size);
-    REQUIRE(helper.size() == expected_size);
-    helper.reopen(false);
-    REQUIRE(helper.size() == expected_size);
-}
-
-static void test_split_ext(const spdlog::filename_t::value_type *fname,
-                           const spdlog::filename_t::value_type *expect_base,
-                           const spdlog::filename_t::value_type *expect_ext) {
-    spdlog::filename_t filename(fname);
-    spdlog::filename_t expected_base(expect_base);
-    spdlog::filename_t expected_ext(expect_ext);
-
-    spdlog::filename_t basename;
-    spdlog::filename_t ext;
-    std::tie(basename, ext) = file_helper::split_by_extension(filename);
-    REQUIRE(basename == expected_base);
-    REQUIRE(ext == expected_ext);
-}
-
-TEST_CASE("file_helper_split_by_extension", "[file_helper::split_by_extension()]") {
-    test_split_ext(SPDLOG_FILENAME_T("mylog.txt"), SPDLOG_FILENAME_T("mylog"),
-                   SPDLOG_FILENAME_T(".txt"));
-    test_split_ext(SPDLOG_FILENAME_T(".mylog.txt"), SPDLOG_FILENAME_T(".mylog"),
-                   SPDLOG_FILENAME_T(".txt"));
-    test_split_ext(SPDLOG_FILENAME_T(".mylog"), SPDLOG_FILENAME_T(".mylog"), SPDLOG_FILENAME_T(""));
-    test_split_ext(SPDLOG_FILENAME_T("/aaa/bb.d/mylog"), SPDLOG_FILENAME_T("/aaa/bb.d/mylog"),
-                   SPDLOG_FILENAME_T(""));
-    test_split_ext(SPDLOG_FILENAME_T("/aaa/bb.d/mylog.txt"), SPDLOG_FILENAME_T("/aaa/bb.d/mylog"),
-                   SPDLOG_FILENAME_T(".txt"));
-    test_split_ext(SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog.txt"),
-                   SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog"), SPDLOG_FILENAME_T(".txt"));
-    test_split_ext(SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog."), SPDLOG_FILENAME_T("aaa/bbb/ccc/mylog."),
-                   SPDLOG_FILENAME_T(""));
-    test_split_ext(SPDLOG_FILENAME_T("aaa/bbb/ccc/.mylog.txt"),
-                   SPDLOG_FILENAME_T("aaa/bbb/ccc/.mylog"), SPDLOG_FILENAME_T(".txt"));
-    test_split_ext(SPDLOG_FILENAME_T("/aaa/bbb/ccc/mylog.txt"),
-                   SPDLOG_FILENAME_T("/aaa/bbb/ccc/mylog"), SPDLOG_FILENAME_T(".txt"));
-    test_split_ext(SPDLOG_FILENAME_T("/aaa/bbb/ccc/.mylog"),
-                   SPDLOG_FILENAME_T("/aaa/bbb/ccc/.mylog"), SPDLOG_FILENAME_T(""));
-    test_split_ext(SPDLOG_FILENAME_T("../mylog.txt"), SPDLOG_FILENAME_T("../mylog"),
-                   SPDLOG_FILENAME_T(".txt"));
-    test_split_ext(SPDLOG_FILENAME_T(".././mylog.txt"), SPDLOG_FILENAME_T(".././mylog"),
-                   SPDLOG_FILENAME_T(".txt"));
-    test_split_ext(SPDLOG_FILENAME_T(".././mylog.txt/xxx"), SPDLOG_FILENAME_T(".././mylog.txt/xxx"),
-                   SPDLOG_FILENAME_T(""));
-    test_split_ext(SPDLOG_FILENAME_T("/mylog.txt"), SPDLOG_FILENAME_T("/mylog"),
-                   SPDLOG_FILENAME_T(".txt"));
-    test_split_ext(SPDLOG_FILENAME_T("//mylog.txt"), SPDLOG_FILENAME_T("//mylog"),
-                   SPDLOG_FILENAME_T(".txt"));
-    test_split_ext(SPDLOG_FILENAME_T(""), SPDLOG_FILENAME_T(""), SPDLOG_FILENAME_T(""));
-    test_split_ext(SPDLOG_FILENAME_T("."), SPDLOG_FILENAME_T("."), SPDLOG_FILENAME_T(""));
-    test_split_ext(SPDLOG_FILENAME_T("..txt"), SPDLOG_FILENAME_T("."), SPDLOG_FILENAME_T(".txt"));
-}
-
-TEST_CASE("file_event_handlers", "[file_helper]") {
-    enum class flags { before_open, after_open, before_close, after_close };
-    prepare_logdir();
-
-    spdlog::filename_t test_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
-    // define event handles that update vector of flags when called
-    std::vector<flags> events;
-    spdlog::file_event_handlers handlers;
-    handlers.before_open = [&](spdlog::filename_t filename) {
-        REQUIRE(filename == test_filename);
-        events.push_back(flags::before_open);
-    };
-    handlers.after_open = [&](spdlog::filename_t filename, std::FILE *fstream) {
-        REQUIRE(filename == test_filename);
-        REQUIRE(fstream);
-        fputs("after_open\n", fstream);
-        events.push_back(flags::after_open);
-    };
-    handlers.before_close = [&](spdlog::filename_t filename, std::FILE *fstream) {
-        REQUIRE(filename == test_filename);
-        REQUIRE(fstream);
-        fputs("before_close\n", fstream);
-        events.push_back(flags::before_close);
-    };
-    handlers.after_close = [&](spdlog::filename_t filename) {
-        REQUIRE(filename == test_filename);
-        events.push_back(flags::after_close);
-    };
-    {
-        spdlog::details::file_helper helper{handlers};
-        REQUIRE(events.empty());
-
-        helper.open(test_filename);
-        REQUIRE(events == std::vector<flags>{flags::before_open, flags::after_open});
-
-        events.clear();
-        helper.close();
-        REQUIRE(events == std::vector<flags>{flags::before_close, flags::after_close});
-        REQUIRE(file_contents(TEST_FILENAME) == "after_open\nbefore_close\n");
-
-        helper.reopen(true);
-        events.clear();
-    }
-    // make sure that the file_helper destrcutor calls the close callbacks if needed
-    REQUIRE(events == std::vector<flags>{flags::before_close, flags::after_close});
-    REQUIRE(file_contents(TEST_FILENAME) == "after_open\nbefore_close\n");
-}
-
-TEST_CASE("file_helper_open", "[file_helper]") {
-    prepare_logdir();
-    spdlog::filename_t target_filename = SPDLOG_FILENAME_T(TEST_FILENAME);
-    file_helper helper;
-    helper.open(target_filename);
-    helper.close();
-
-    target_filename += SPDLOG_FILENAME_T("/invalid");
-    REQUIRE_THROWS_AS(helper.open(target_filename), spdlog::spdlog_ex);
-}
diff --git a/Dependencies/spdlog/tests/test_file_logging.cpp b/Dependencies/spdlog/tests/test_file_logging.cpp
deleted file mode 100644
index ac378b5c..00000000
--- a/Dependencies/spdlog/tests/test_file_logging.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * This content is released under the MIT License as specified in
- * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
- */
-#include "includes.h"
-
-#define SIMPLE_LOG "test_logs/simple_log"
-#define ROTATING_LOG "test_logs/rotating_log"
-
-TEST_CASE("simple_file_logger", "[simple_logger]") {
-    prepare_logdir();
-    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
-
-    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
-    logger->set_pattern("%v");
-
-    logger->info("Test message {}", 1);
-    logger->info("Test message {}", 2);
-
-    logger->flush();
-    require_message_count(SIMPLE_LOG, 2);
-    using spdlog::details::os::default_eol;
-    REQUIRE(file_contents(SIMPLE_LOG) ==
-            spdlog::fmt_lib::format("Test message 1{}Test message 2{}", default_eol, default_eol));
-}
-
-TEST_CASE("flush_on", "[flush_on]") {
-    prepare_logdir();
-    spdlog::filename_t filename = SPDLOG_FILENAME_T(SIMPLE_LOG);
-
-    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
-    logger->set_pattern("%v");
-    logger->set_level(spdlog::level::trace);
-    logger->flush_on(spdlog::level::info);
-    logger->trace("Should not be flushed");
-    REQUIRE(count_lines(SIMPLE_LOG) == 0);
-
-    logger->info("Test message {}", 1);
-    logger->info("Test message {}", 2);
-
-    require_message_count(SIMPLE_LOG, 3);
-    using spdlog::details::os::default_eol;
-    REQUIRE(file_contents(SIMPLE_LOG) ==
-            spdlog::fmt_lib::format("Should not be flushed{}Test message 1{}Test message 2{}",
-                                    default_eol, default_eol, default_eol));
-}
-
-TEST_CASE("rotating_file_logger1", "[rotating_logger]") {
-    prepare_logdir();
-    size_t max_size = 1024 * 10;
-    spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);
-    auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 0);
-
-    for (int i = 0; i < 10; ++i) {
-        logger->info("Test message {}", i);
-    }
-
-    logger->flush();
-    require_message_count(ROTATING_LOG, 10);
-}
-
-TEST_CASE("rotating_file_logger2", "[rotating_logger]") {
-    prepare_logdir();
-    size_t max_size = 1024 * 10;
-    spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);
-
-    {
-        // make an initial logger to create the first output file
-        auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true);
-        for (int i = 0; i < 10; ++i) {
-            logger->info("Test message {}", i);
-        }
-        // drop causes the logger destructor to be called, which is required so the
-        // next logger can rename the first output file.
-        spdlog::drop(logger->name());
-    }
-
-    auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true);
-    for (int i = 0; i < 10; ++i) {
-        logger->info("Test message {}", i);
-    }
-
-    logger->flush();
-
-    require_message_count(ROTATING_LOG, 10);
-
-    for (int i = 0; i < 1000; i++) {
-        logger->info("Test message {}", i);
-    }
-
-    logger->flush();
-    REQUIRE(get_filesize(ROTATING_LOG) <= max_size);
-    REQUIRE(get_filesize(ROTATING_LOG ".1") <= max_size);
-}
-
-// test that passing max_size=0 throws
-TEST_CASE("rotating_file_logger3", "[rotating_logger]") {
-    prepare_logdir();
-    size_t max_size = 0;
-    spdlog::filename_t basename = SPDLOG_FILENAME_T(ROTATING_LOG);
-    REQUIRE_THROWS_AS(spdlog::rotating_logger_mt("logger", basename, max_size, 0),
-                      spdlog::spdlog_ex);
-}
diff --git a/Dependencies/spdlog/tests/test_fmt_helper.cpp b/Dependencies/spdlog/tests/test_fmt_helper.cpp
deleted file mode 100644
index 31b93067..00000000
--- a/Dependencies/spdlog/tests/test_fmt_helper.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-
-#include "includes.h"
-
-using spdlog::memory_buf_t;
-using spdlog::details::to_string_view;
-
-void test_pad2(int n, const char *expected) {
-    memory_buf_t buf;
-    spdlog::details::fmt_helper::pad2(n, buf);
-
-    REQUIRE(to_string_view(buf) == expected);
-}
-
-void test_pad3(uint32_t n, const char *expected) {
-    memory_buf_t buf;
-    spdlog::details::fmt_helper::pad3(n, buf);
-
-    REQUIRE(to_string_view(buf) == expected);
-}
-
-void test_pad6(std::size_t n, const char *expected) {
-    memory_buf_t buf;
-    spdlog::details::fmt_helper::pad6(n, buf);
-
-    REQUIRE(to_string_view(buf) == expected);
-}
-
-void test_pad9(std::size_t n, const char *expected) {
-    memory_buf_t buf;
-    spdlog::details::fmt_helper::pad9(n, buf);
-
-    REQUIRE(to_string_view(buf) == expected);
-}
-
-TEST_CASE("pad2", "[fmt_helper]") {
-    test_pad2(0, "00");
-    test_pad2(3, "03");
-    test_pad2(10, "10");
-    test_pad2(23, "23");
-    test_pad2(99, "99");
-    test_pad2(100, "100");
-    test_pad2(123, "123");
-    test_pad2(1234, "1234");
-    test_pad2(-5, "-5");
-}
-
-TEST_CASE("pad3", "[fmt_helper]") {
-    test_pad3(0, "000");
-    test_pad3(3, "003");
-    test_pad3(10, "010");
-    test_pad3(23, "023");
-    test_pad3(99, "099");
-    test_pad3(100, "100");
-    test_pad3(123, "123");
-    test_pad3(999, "999");
-    test_pad3(1000, "1000");
-    test_pad3(1234, "1234");
-}
-
-TEST_CASE("pad6", "[fmt_helper]") {
-    test_pad6(0, "000000");
-    test_pad6(3, "000003");
-    test_pad6(23, "000023");
-    test_pad6(123, "000123");
-    test_pad6(1234, "001234");
-    test_pad6(12345, "012345");
-    test_pad6(123456, "123456");
-}
-
-TEST_CASE("pad9", "[fmt_helper]") {
-    test_pad9(0, "000000000");
-    test_pad9(3, "000000003");
-    test_pad9(23, "000000023");
-    test_pad9(123, "000000123");
-    test_pad9(1234, "000001234");
-    test_pad9(12345, "000012345");
-    test_pad9(123456, "000123456");
-    test_pad9(1234567, "001234567");
-    test_pad9(12345678, "012345678");
-    test_pad9(123456789, "123456789");
-    test_pad9(1234567891, "1234567891");
-}
diff --git a/Dependencies/spdlog/tests/test_macros.cpp b/Dependencies/spdlog/tests/test_macros.cpp
deleted file mode 100644
index 132706f1..00000000
--- a/Dependencies/spdlog/tests/test_macros.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * This content is released under the MIT License as specified in
- * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
- */
-
-#include "includes.h"
-
-#if SPDLOG_ACTIVE_LEVEL != SPDLOG_LEVEL_DEBUG
-    #error "Invalid SPDLOG_ACTIVE_LEVEL in test. Should be SPDLOG_LEVEL_DEBUG"
-#endif
-
-#define TEST_FILENAME "test_logs/simple_log"
-
-TEST_CASE("debug and trace w/o format string", "[macros]") {
-    prepare_logdir();
-    spdlog::filename_t filename = SPDLOG_FILENAME_T(TEST_FILENAME);
-
-    auto logger = spdlog::create<spdlog::sinks::basic_file_sink_mt>("logger", filename);
-    logger->set_pattern("%v");
-    logger->set_level(spdlog::level::trace);
-
-    SPDLOG_LOGGER_TRACE(logger, "Test message 1");
-    SPDLOG_LOGGER_DEBUG(logger, "Test message 2");
-    logger->flush();
-
-    using spdlog::details::os::default_eol;
-    REQUIRE(ends_with(file_contents(TEST_FILENAME),
-                      spdlog::fmt_lib::format("Test message 2{}", default_eol)));
-    REQUIRE(count_lines(TEST_FILENAME) == 1);
-
-    auto orig_default_logger = spdlog::default_logger();
-    spdlog::set_default_logger(logger);
-
-    SPDLOG_TRACE("Test message 3");
-    SPDLOG_DEBUG("Test message {}", 4);
-    logger->flush();
-
-    require_message_count(TEST_FILENAME, 2);
-    REQUIRE(ends_with(file_contents(TEST_FILENAME),
-                      spdlog::fmt_lib::format("Test message 4{}", default_eol)));
-    spdlog::set_default_logger(std::move(orig_default_logger));
-}
-
-TEST_CASE("disable param evaluation", "[macros]") {
-    SPDLOG_TRACE("Test message {}", throw std::runtime_error("Should not be evaluated"));
-}
-
-TEST_CASE("pass logger pointer", "[macros]") {
-    auto logger = spdlog::create<spdlog::sinks::null_sink_mt>("refmacro");
-    auto &ref = *logger;
-    SPDLOG_LOGGER_TRACE(&ref, "Test message 1");
-    SPDLOG_LOGGER_DEBUG(&ref, "Test message 2");
-}
diff --git a/Dependencies/spdlog/tests/test_misc.cpp b/Dependencies/spdlog/tests/test_misc.cpp
deleted file mode 100644
index 367eeb75..00000000
--- a/Dependencies/spdlog/tests/test_misc.cpp
+++ /dev/null
@@ -1,169 +0,0 @@
-#include "includes.h"
-#include "test_sink.h"
-
-template <class T>
-std::string log_info(const T &what, spdlog::level::level_enum logger_level = spdlog::level::info) {
-    std::ostringstream oss;
-    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
-
-    spdlog::logger oss_logger("oss", oss_sink);
-    oss_logger.set_level(logger_level);
-    oss_logger.set_pattern("%v");
-    oss_logger.info(what);
-
-    return oss.str().substr(0, oss.str().length() - strlen(spdlog::details::os::default_eol));
-}
-
-TEST_CASE("basic_logging ", "[basic_logging]") {
-    // const char
-    REQUIRE(log_info("Hello") == "Hello");
-    REQUIRE(log_info("").empty());
-
-    // std::string
-    REQUIRE(log_info(std::string("Hello")) == "Hello");
-    REQUIRE(log_info(std::string()).empty());
-
-    // Numbers
-    REQUIRE(log_info(5) == "5");
-    REQUIRE(log_info(5.6) == "5.6");
-
-    // User defined class
-    // REQUIRE(log_info(some_logged_class("some_val")) == "some_val");
-}
-
-TEST_CASE("log_levels", "[log_levels]") {
-    REQUIRE(log_info("Hello", spdlog::level::err).empty());
-    REQUIRE(log_info("Hello", spdlog::level::critical).empty());
-    REQUIRE(log_info("Hello", spdlog::level::info) == "Hello");
-    REQUIRE(log_info("Hello", spdlog::level::debug) == "Hello");
-    REQUIRE(log_info("Hello", spdlog::level::trace) == "Hello");
-}
-
-TEST_CASE("level_to_string_view", "[convert_to_string_view]") {
-    REQUIRE(spdlog::level::to_string_view(spdlog::level::trace) == "trace");
-    REQUIRE(spdlog::level::to_string_view(spdlog::level::debug) == "debug");
-    REQUIRE(spdlog::level::to_string_view(spdlog::level::info) == "info");
-    REQUIRE(spdlog::level::to_string_view(spdlog::level::warn) == "warning");
-    REQUIRE(spdlog::level::to_string_view(spdlog::level::err) == "error");
-    REQUIRE(spdlog::level::to_string_view(spdlog::level::critical) == "critical");
-    REQUIRE(spdlog::level::to_string_view(spdlog::level::off) == "off");
-}
-
-TEST_CASE("to_short_c_str", "[convert_to_short_c_str]") {
-    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::trace)) == "T");
-    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::debug)) == "D");
-    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::info)) == "I");
-    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::warn)) == "W");
-    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::err)) == "E");
-    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::critical)) == "C");
-    REQUIRE(std::string(spdlog::level::to_short_c_str(spdlog::level::off)) == "O");
-}
-
-TEST_CASE("to_level_enum", "[convert_to_level_enum]") {
-    REQUIRE(spdlog::level::from_str("trace") == spdlog::level::trace);
-    REQUIRE(spdlog::level::from_str("debug") == spdlog::level::debug);
-    REQUIRE(spdlog::level::from_str("info") == spdlog::level::info);
-    REQUIRE(spdlog::level::from_str("warning") == spdlog::level::warn);
-    REQUIRE(spdlog::level::from_str("warn") == spdlog::level::warn);
-    REQUIRE(spdlog::level::from_str("error") == spdlog::level::err);
-    REQUIRE(spdlog::level::from_str("critical") == spdlog::level::critical);
-    REQUIRE(spdlog::level::from_str("off") == spdlog::level::off);
-    REQUIRE(spdlog::level::from_str("null") == spdlog::level::off);
-}
-
-TEST_CASE("periodic flush", "[periodic_flush]") {
-    using spdlog::sinks::test_sink_mt;
-    auto logger = spdlog::create<test_sink_mt>("periodic_flush");
-    auto test_sink = std::static_pointer_cast<test_sink_mt>(logger->sinks()[0]);
-
-    spdlog::flush_every(std::chrono::seconds(1));
-    std::this_thread::sleep_for(std::chrono::milliseconds(1250));
-    REQUIRE(test_sink->flush_counter() == 1);
-    spdlog::flush_every(std::chrono::seconds(0));
-    spdlog::drop_all();
-}
-
-TEST_CASE("clone-logger", "[clone]") {
-    using spdlog::sinks::test_sink_mt;
-    auto test_sink = std::make_shared<test_sink_mt>();
-    auto logger = std::make_shared<spdlog::logger>("orig", test_sink);
-    logger->set_pattern("%v");
-    auto cloned = logger->clone("clone");
-
-    REQUIRE(cloned->name() == "clone");
-    REQUIRE(logger->sinks() == cloned->sinks());
-    REQUIRE(logger->level() == cloned->level());
-    REQUIRE(logger->flush_level() == cloned->flush_level());
-    logger->info("Some message 1");
-    cloned->info("Some message 2");
-
-    REQUIRE(test_sink->lines().size() == 2);
-    REQUIRE(test_sink->lines()[0] == "Some message 1");
-    REQUIRE(test_sink->lines()[1] == "Some message 2");
-
-    spdlog::drop_all();
-}
-
-TEST_CASE("clone async", "[clone]") {
-    using spdlog::sinks::test_sink_st;
-    spdlog::init_thread_pool(4, 1);
-    auto test_sink = std::make_shared<test_sink_st>();
-    auto logger = std::make_shared<spdlog::async_logger>("orig", test_sink, spdlog::thread_pool());
-    logger->set_pattern("%v");
-    auto cloned = logger->clone("clone");
-
-    REQUIRE(cloned->name() == "clone");
-    REQUIRE(logger->sinks() == cloned->sinks());
-    REQUIRE(logger->level() == cloned->level());
-    REQUIRE(logger->flush_level() == cloned->flush_level());
-
-    logger->info("Some message 1");
-    cloned->info("Some message 2");
-
-    spdlog::details::os::sleep_for_millis(100);
-
-    REQUIRE(test_sink->lines().size() == 2);
-    REQUIRE(test_sink->lines()[0] == "Some message 1");
-    REQUIRE(test_sink->lines()[1] == "Some message 2");
-
-    spdlog::drop_all();
-}
-
-TEST_CASE("default logger API", "[default logger]") {
-    std::ostringstream oss;
-    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
-
-    spdlog::set_default_logger(std::make_shared<spdlog::logger>("oss", oss_sink));
-    spdlog::set_pattern("*** %v");
-
-    spdlog::default_logger()->set_level(spdlog::level::trace);
-    spdlog::trace("hello trace");
-    REQUIRE(oss.str() == "*** hello trace" + std::string(spdlog::details::os::default_eol));
-
-    oss.str("");
-    spdlog::debug("hello debug");
-    REQUIRE(oss.str() == "*** hello debug" + std::string(spdlog::details::os::default_eol));
-
-    oss.str("");
-    spdlog::info("Hello");
-    REQUIRE(oss.str() == "*** Hello" + std::string(spdlog::details::os::default_eol));
-
-    oss.str("");
-    spdlog::warn("Hello again {}", 2);
-    REQUIRE(oss.str() == "*** Hello again 2" + std::string(spdlog::details::os::default_eol));
-
-    oss.str("");
-    spdlog::error(123);
-    REQUIRE(oss.str() == "*** 123" + std::string(spdlog::details::os::default_eol));
-
-    oss.str("");
-    spdlog::critical(std::string("some string"));
-    REQUIRE(oss.str() == "*** some string" + std::string(spdlog::details::os::default_eol));
-
-    oss.str("");
-    spdlog::set_level(spdlog::level::info);
-    spdlog::debug("should not be logged");
-    REQUIRE(oss.str().empty());
-    spdlog::drop_all();
-    spdlog::set_pattern("%v");
-}
diff --git a/Dependencies/spdlog/tests/test_mpmc_q.cpp b/Dependencies/spdlog/tests/test_mpmc_q.cpp
deleted file mode 100644
index bc7a37d9..00000000
--- a/Dependencies/spdlog/tests/test_mpmc_q.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-#include "includes.h"
-
-using std::chrono::milliseconds;
-using test_clock = std::chrono::high_resolution_clock;
-
-static milliseconds millis_from(const test_clock::time_point &tp0) {
-    return std::chrono::duration_cast<milliseconds>(test_clock::now() - tp0);
-}
-TEST_CASE("dequeue-empty-nowait", "[mpmc_blocking_q]") {
-    size_t q_size = 100;
-    milliseconds tolerance_wait(20);
-    spdlog::details::mpmc_blocking_queue<int> q(q_size);
-    int popped_item = 0;
-
-    auto start = test_clock::now();
-    auto rv = q.dequeue_for(popped_item, milliseconds::zero());
-    auto delta_ms = millis_from(start);
-
-    REQUIRE(rv == false);
-    INFO("Delta " << delta_ms.count() << " millis");
-    REQUIRE(delta_ms <= tolerance_wait);
-}
-
-TEST_CASE("dequeue-empty-wait", "[mpmc_blocking_q]") {
-    size_t q_size = 100;
-    milliseconds wait_ms(250);
-    milliseconds tolerance_wait(250);
-
-    spdlog::details::mpmc_blocking_queue<int> q(q_size);
-    int popped_item = 0;
-    auto start = test_clock::now();
-    auto rv = q.dequeue_for(popped_item, wait_ms);
-    auto delta_ms = millis_from(start);
-
-    REQUIRE(rv == false);
-
-    INFO("Delta " << delta_ms.count() << " millis");
-    REQUIRE(delta_ms >= wait_ms - tolerance_wait);
-    REQUIRE(delta_ms <= wait_ms + tolerance_wait);
-}
-
-TEST_CASE("dequeue-full-nowait", "[mpmc_blocking_q]") {
-    spdlog::details::mpmc_blocking_queue<int> q(1);
-    q.enqueue(42);
-
-    int item = 0;
-    q.dequeue_for(item, milliseconds::zero());
-    REQUIRE(item == 42);
-}
-
-TEST_CASE("dequeue-full-wait", "[mpmc_blocking_q]") {
-    spdlog::details::mpmc_blocking_queue<int> q(1);
-    q.enqueue(42);
-
-    int item = 0;
-    q.dequeue(item);
-    REQUIRE(item == 42);
-}
-
-TEST_CASE("enqueue_nowait", "[mpmc_blocking_q]") {
-    size_t q_size = 1;
-    spdlog::details::mpmc_blocking_queue<int> q(q_size);
-    milliseconds tolerance_wait(10);
-
-    q.enqueue(1);
-    REQUIRE(q.overrun_counter() == 0);
-
-    auto start = test_clock::now();
-    q.enqueue_nowait(2);
-    auto delta_ms = millis_from(start);
-
-    INFO("Delta " << delta_ms.count() << " millis");
-    REQUIRE(delta_ms <= tolerance_wait);
-    REQUIRE(q.overrun_counter() == 1);
-}
-
-TEST_CASE("bad_queue", "[mpmc_blocking_q]") {
-    size_t q_size = 0;
-    spdlog::details::mpmc_blocking_queue<int> q(q_size);
-    q.enqueue_nowait(1);
-    REQUIRE(q.overrun_counter() == 1);
-    int i = 0;
-    REQUIRE(q.dequeue_for(i, milliseconds(0)) == false);
-}
-
-TEST_CASE("empty_queue", "[mpmc_blocking_q]") {
-    size_t q_size = 10;
-    spdlog::details::mpmc_blocking_queue<int> q(q_size);
-    int i = 0;
-    REQUIRE(q.dequeue_for(i, milliseconds(10)) == false);
-}
-
-TEST_CASE("full_queue", "[mpmc_blocking_q]") {
-    size_t q_size = 100;
-    spdlog::details::mpmc_blocking_queue<int> q(q_size);
-    for (int i = 0; i < static_cast<int>(q_size); i++) {
-        q.enqueue(i + 0);  // i+0 to force rvalue and avoid tidy warnings on the same time if we
-                           // std::move(i) instead
-    }
-
-    q.enqueue_nowait(123456);
-    REQUIRE(q.overrun_counter() == 1);
-
-    for (int i = 1; i < static_cast<int>(q_size); i++) {
-        int item = -1;
-        q.dequeue(item);
-        REQUIRE(item == i);
-    }
-
-    // last item pushed has overridden the oldest.
-    int item = -1;
-    q.dequeue(item);
-    REQUIRE(item == 123456);
-}
diff --git a/Dependencies/spdlog/tests/test_pattern_formatter.cpp b/Dependencies/spdlog/tests/test_pattern_formatter.cpp
deleted file mode 100644
index 350b973b..00000000
--- a/Dependencies/spdlog/tests/test_pattern_formatter.cpp
+++ /dev/null
@@ -1,502 +0,0 @@
-#include "includes.h"
-#include "test_sink.h"
-
-using spdlog::memory_buf_t;
-using spdlog::details::to_string_view;
-
-// log to str and return it
-template <typename... Args>
-static std::string log_to_str(const std::string &msg, const Args &...args) {
-    std::ostringstream oss;
-    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
-    spdlog::logger oss_logger("pattern_tester", oss_sink);
-    oss_logger.set_level(spdlog::level::info);
-
-    oss_logger.set_formatter(
-        std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(args...)));
-
-    oss_logger.info(msg);
-    return oss.str();
-}
-
-TEST_CASE("custom eol", "[pattern_formatter]") {
-    std::string msg = "Hello custom eol test";
-    std::string eol = ";)";
-    REQUIRE(log_to_str(msg, "%v", spdlog::pattern_time_type::local, ";)") == msg + eol);
-}
-
-TEST_CASE("empty format", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "", spdlog::pattern_time_type::local, "").empty());
-}
-
-TEST_CASE("empty format2", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "", spdlog::pattern_time_type::local, "\n") == "\n");
-}
-
-TEST_CASE("level", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%l] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[info] Some message\n");
-}
-
-TEST_CASE("short level", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%L] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[I] Some message\n");
-}
-
-TEST_CASE("name", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pattern_tester] Some message\n");
-}
-
-TEST_CASE("date MM/DD/YY ", "[pattern_formatter]") {
-    auto now_tm = spdlog::details::os::localtime();
-    std::stringstream oss;
-    oss << std::setfill('0') << std::setw(2) << now_tm.tm_mon + 1 << "/" << std::setw(2)
-        << now_tm.tm_mday << "/" << std::setw(2) << (now_tm.tm_year + 1900) % 1000
-        << " Some message\n";
-    REQUIRE(log_to_str("Some message", "%D %v", spdlog::pattern_time_type::local, "\n") ==
-            oss.str());
-}
-
-TEST_CASE("color range test1", "[pattern_formatter]") {
-    auto formatter = std::make_shared<spdlog::pattern_formatter>(
-        "%^%v%$", spdlog::pattern_time_type::local, "\n");
-
-    memory_buf_t buf;
-    spdlog::fmt_lib::format_to(std::back_inserter(buf), "Hello");
-    memory_buf_t formatted;
-    std::string logger_name = "test";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info,
-                                 spdlog::string_view_t(buf.data(), buf.size()));
-    formatter->format(msg, formatted);
-    REQUIRE(msg.color_range_start == 0);
-    REQUIRE(msg.color_range_end == 5);
-    REQUIRE(log_to_str("hello", "%^%v%$", spdlog::pattern_time_type::local, "\n") == "hello\n");
-}
-
-TEST_CASE("color range test2", "[pattern_formatter]") {
-    auto formatter =
-        std::make_shared<spdlog::pattern_formatter>("%^%$", spdlog::pattern_time_type::local, "\n");
-    std::string logger_name = "test";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "");
-    memory_buf_t formatted;
-    formatter->format(msg, formatted);
-    REQUIRE(msg.color_range_start == 0);
-    REQUIRE(msg.color_range_end == 0);
-    REQUIRE(log_to_str("", "%^%$", spdlog::pattern_time_type::local, "\n") == "\n");
-}
-
-TEST_CASE("color range test3", "[pattern_formatter]") {
-    auto formatter = std::make_shared<spdlog::pattern_formatter>("%^***%$");
-    std::string logger_name = "test";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored");
-    memory_buf_t formatted;
-    formatter->format(msg, formatted);
-    REQUIRE(msg.color_range_start == 0);
-    REQUIRE(msg.color_range_end == 3);
-}
-
-TEST_CASE("color range test4", "[pattern_formatter]") {
-    auto formatter = std::make_shared<spdlog::pattern_formatter>(
-        "XX%^YYY%$", spdlog::pattern_time_type::local, "\n");
-    std::string logger_name = "test";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored");
-
-    memory_buf_t formatted;
-    formatter->format(msg, formatted);
-    REQUIRE(msg.color_range_start == 2);
-    REQUIRE(msg.color_range_end == 5);
-    REQUIRE(log_to_str("ignored", "XX%^YYY%$", spdlog::pattern_time_type::local, "\n") ==
-            "XXYYY\n");
-}
-
-TEST_CASE("color range test5", "[pattern_formatter]") {
-    auto formatter = std::make_shared<spdlog::pattern_formatter>("**%^");
-    std::string logger_name = "test";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored");
-    memory_buf_t formatted;
-    formatter->format(msg, formatted);
-    REQUIRE(msg.color_range_start == 2);
-    REQUIRE(msg.color_range_end == 0);
-}
-
-TEST_CASE("color range test6", "[pattern_formatter]") {
-    auto formatter = std::make_shared<spdlog::pattern_formatter>("**%$");
-    std::string logger_name = "test";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "ignored");
-    memory_buf_t formatted;
-    formatter->format(msg, formatted);
-    REQUIRE(msg.color_range_start == 0);
-    REQUIRE(msg.color_range_end == 2);
-}
-
-//
-// Test padding
-//
-
-TEST_CASE("level_left_padded", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%8l] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[    info] Some message\n");
-    REQUIRE(log_to_str("Some message", "[%8!l] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[    info] Some message\n");
-}
-
-TEST_CASE("level_right_padded", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%-8l] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[info    ] Some message\n");
-    REQUIRE(log_to_str("Some message", "[%-8!l] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[info    ] Some message\n");
-}
-
-TEST_CASE("level_center_padded", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%=8l] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[  info  ] Some message\n");
-    REQUIRE(log_to_str("Some message", "[%=8!l] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[  info  ] Some message\n");
-}
-
-TEST_CASE("short level_left_padded", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%3L] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[  I] Some message\n");
-    REQUIRE(log_to_str("Some message", "[%3!L] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[  I] Some message\n");
-}
-
-TEST_CASE("short level_right_padded", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%-3L] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[I  ] Some message\n");
-    REQUIRE(log_to_str("Some message", "[%-3!L] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[I  ] Some message\n");
-}
-
-TEST_CASE("short level_center_padded", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%=3L] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[ I ] Some message\n");
-    REQUIRE(log_to_str("Some message", "[%=3!L] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[ I ] Some message\n");
-}
-
-TEST_CASE("left_padded_short", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%3n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pattern_tester] Some message\n");
-    REQUIRE(log_to_str("Some message", "[%3!n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pat] Some message\n");
-}
-
-TEST_CASE("right_padded_short", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%-3n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pattern_tester] Some message\n");
-    REQUIRE(log_to_str("Some message", "[%-3!n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pat] Some message\n");
-}
-
-TEST_CASE("center_padded_short", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%=3n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pattern_tester] Some message\n");
-    REQUIRE(log_to_str("Some message", "[%=3!n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pat] Some message\n");
-}
-
-TEST_CASE("left_padded_huge", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%-300n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pattern_tester                                                  ] Some message\n");
-
-    REQUIRE(log_to_str("Some message", "[%-300!n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pattern_tester                                                  ] Some message\n");
-}
-
-TEST_CASE("left_padded_max", "[pattern_formatter]") {
-    REQUIRE(log_to_str("Some message", "[%-64n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pattern_tester                                                  ] Some message\n");
-
-    REQUIRE(log_to_str("Some message", "[%-64!n] %v", spdlog::pattern_time_type::local, "\n") ==
-            "[pattern_tester                                                  ] Some message\n");
-}
-
-// Test padding + truncate flag
-
-TEST_CASE("paddinng_truncate", "[pattern_formatter]") {
-    REQUIRE(log_to_str("123456", "%6!v", spdlog::pattern_time_type::local, "\n") == "123456\n");
-    REQUIRE(log_to_str("123456", "%5!v", spdlog::pattern_time_type::local, "\n") == "12345\n");
-    REQUIRE(log_to_str("123456", "%7!v", spdlog::pattern_time_type::local, "\n") == " 123456\n");
-
-    REQUIRE(log_to_str("123456", "%-6!v", spdlog::pattern_time_type::local, "\n") == "123456\n");
-    REQUIRE(log_to_str("123456", "%-5!v", spdlog::pattern_time_type::local, "\n") == "12345\n");
-    REQUIRE(log_to_str("123456", "%-7!v", spdlog::pattern_time_type::local, "\n") == "123456 \n");
-
-    REQUIRE(log_to_str("123456", "%=6!v", spdlog::pattern_time_type::local, "\n") == "123456\n");
-    REQUIRE(log_to_str("123456", "%=5!v", spdlog::pattern_time_type::local, "\n") == "12345\n");
-    REQUIRE(log_to_str("123456", "%=7!v", spdlog::pattern_time_type::local, "\n") == "123456 \n");
-
-    REQUIRE(log_to_str("123456", "%0!v", spdlog::pattern_time_type::local, "\n") == "\n");
-}
-
-TEST_CASE("padding_truncate_funcname", "[pattern_formatter]") {
-    spdlog::sinks::test_sink_st test_sink;
-
-    const char *pattern = "%v [%5!!]";
-    auto formatter = std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(pattern));
-    test_sink.set_formatter(std::move(formatter));
-
-    spdlog::details::log_msg msg1{spdlog::source_loc{"ignored", 1, "func"}, "test_logger",
-                                  spdlog::level::info, "message"};
-    test_sink.log(msg1);
-    REQUIRE(test_sink.lines()[0] == "message [ func]");
-
-    spdlog::details::log_msg msg2{spdlog::source_loc{"ignored", 1, "function"}, "test_logger",
-                                  spdlog::level::info, "message"};
-    test_sink.log(msg2);
-    REQUIRE(test_sink.lines()[1] == "message [funct]");
-}
-
-TEST_CASE("padding_funcname", "[pattern_formatter]") {
-    spdlog::sinks::test_sink_st test_sink;
-
-    const char *pattern = "%v [%10!]";
-    auto formatter = std::unique_ptr<spdlog::formatter>(new spdlog::pattern_formatter(pattern));
-    test_sink.set_formatter(std::move(formatter));
-
-    spdlog::details::log_msg msg1{spdlog::source_loc{"ignored", 1, "func"}, "test_logger",
-                                  spdlog::level::info, "message"};
-    test_sink.log(msg1);
-    REQUIRE(test_sink.lines()[0] == "message [      func]");
-
-    spdlog::details::log_msg msg2{spdlog::source_loc{"ignored", 1, "func567890123"}, "test_logger",
-                                  spdlog::level::info, "message"};
-    test_sink.log(msg2);
-    REQUIRE(test_sink.lines()[1] == "message [func567890123]");
-}
-
-TEST_CASE("clone-default-formatter", "[pattern_formatter]") {
-    auto formatter_1 = std::make_shared<spdlog::pattern_formatter>();
-    auto formatter_2 = formatter_1->clone();
-    std::string logger_name = "test";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message");
-
-    memory_buf_t formatted_1;
-    memory_buf_t formatted_2;
-    formatter_1->format(msg, formatted_1);
-    formatter_2->format(msg, formatted_2);
-
-    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
-}
-
-TEST_CASE("clone-default-formatter2", "[pattern_formatter]") {
-    auto formatter_1 = std::make_shared<spdlog::pattern_formatter>("%+");
-    auto formatter_2 = formatter_1->clone();
-    std::string logger_name = "test";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message");
-
-    memory_buf_t formatted_1;
-    memory_buf_t formatted_2;
-    formatter_1->format(msg, formatted_1);
-    formatter_2->format(msg, formatted_2);
-
-    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
-}
-
-TEST_CASE("clone-formatter", "[pattern_formatter]") {
-    auto formatter_1 = std::make_shared<spdlog::pattern_formatter>("%D %X [%] [%n] %v");
-    auto formatter_2 = formatter_1->clone();
-    std::string logger_name = "test";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message");
-
-    memory_buf_t formatted_1;
-    memory_buf_t formatted_2;
-    formatter_1->format(msg, formatted_1);
-    formatter_2->format(msg, formatted_2);
-
-    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
-}
-
-TEST_CASE("clone-formatter-2", "[pattern_formatter]") {
-    using spdlog::pattern_time_type;
-    auto formatter_1 = std::make_shared<spdlog::pattern_formatter>(
-        "%D %X [%] [%n] %v", pattern_time_type::utc, "xxxxxx\n");
-    auto formatter_2 = formatter_1->clone();
-    std::string logger_name = "test2";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message");
-
-    memory_buf_t formatted_1;
-    memory_buf_t formatted_2;
-    formatter_1->format(msg, formatted_1);
-    formatter_2->format(msg, formatted_2);
-
-    REQUIRE(to_string_view(formatted_1) == to_string_view(formatted_2));
-}
-
-class custom_test_flag : public spdlog::custom_flag_formatter {
-public:
-    explicit custom_test_flag(std::string txt)
-        : some_txt{std::move(txt)} {}
-
-    void format(const spdlog::details::log_msg &,
-                const std::tm &tm,
-                spdlog::memory_buf_t &dest) override {
-        if (some_txt == "throw_me") {
-            throw spdlog::spdlog_ex("custom_flag_exception_test");
-        } else if (some_txt == "time") {
-            auto formatted = spdlog::fmt_lib::format("{:d}:{:02d}{:s}", tm.tm_hour % 12, tm.tm_min,
-                                                     tm.tm_hour / 12 ? "PM" : "AM");
-            dest.append(formatted.data(), formatted.data() + formatted.size());
-            return;
-        }
-        some_txt = std::string(padinfo_.width_, ' ') + some_txt;
-        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
-    }
-    spdlog::details::padding_info get_padding_info() { return padinfo_; }
-
-    std::string some_txt;
-
-    std::unique_ptr<custom_flag_formatter> clone() const override {
-        return spdlog::details::make_unique<custom_test_flag>(some_txt);
-    }
-};
-// test clone with custom flag formatters
-TEST_CASE("clone-custom_formatter", "[pattern_formatter]") {
-    auto formatter_1 = std::make_shared<spdlog::pattern_formatter>();
-    formatter_1->add_flag<custom_test_flag>('t', "custom_output").set_pattern("[%n] [%t] %v");
-    auto formatter_2 = formatter_1->clone();
-    std::string logger_name = "logger-name";
-    spdlog::details::log_msg msg(logger_name, spdlog::level::info, "some message");
-
-    memory_buf_t formatted_1;
-    memory_buf_t formatted_2;
-    formatter_1->format(msg, formatted_1);
-    formatter_2->format(msg, formatted_2);
-
-    auto expected = spdlog::fmt_lib::format("[logger-name] [custom_output] some message{}",
-                                            spdlog::details::os::default_eol);
-
-    REQUIRE(to_string_view(formatted_1) == expected);
-    REQUIRE(to_string_view(formatted_2) == expected);
-}
-
-//
-// Test source location formatting
-//
-
-#ifdef _WIN32
-static const char *const test_path = "\\a\\b\\c/myfile.cpp";
-#else
-static const char *const test_path = "/a/b//myfile.cpp";
-#endif
-
-TEST_CASE("short filename formatter-1", "[pattern_formatter]") {
-    spdlog::pattern_formatter formatter("%s", spdlog::pattern_time_type::local, "");
-    memory_buf_t formatted;
-    std::string logger_name = "logger-name";
-    spdlog::source_loc source_loc{test_path, 123, "some_func()"};
-    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
-    formatter.format(msg, formatted);
-
-    REQUIRE(to_string_view(formatted) == "myfile.cpp");
-}
-
-TEST_CASE("short filename formatter-2", "[pattern_formatter]") {
-    spdlog::pattern_formatter formatter("%s:%#", spdlog::pattern_time_type::local, "");
-    memory_buf_t formatted;
-    std::string logger_name = "logger-name";
-    spdlog::source_loc source_loc{"myfile.cpp", 123, "some_func()"};
-    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
-    formatter.format(msg, formatted);
-
-    REQUIRE(to_string_view(formatted) == "myfile.cpp:123");
-}
-
-TEST_CASE("short filename formatter-3", "[pattern_formatter]") {
-    spdlog::pattern_formatter formatter("%s %v", spdlog::pattern_time_type::local, "");
-    memory_buf_t formatted;
-    std::string logger_name = "logger-name";
-    spdlog::source_loc source_loc{"", 123, "some_func()"};
-    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
-    formatter.format(msg, formatted);
-
-    REQUIRE(to_string_view(formatted) == " Hello");
-}
-
-TEST_CASE("full filename formatter", "[pattern_formatter]") {
-    spdlog::pattern_formatter formatter("%g", spdlog::pattern_time_type::local, "");
-    memory_buf_t formatted;
-    std::string logger_name = "logger-name";
-    spdlog::source_loc source_loc{test_path, 123, "some_func()"};
-    spdlog::details::log_msg msg(source_loc, "logger-name", spdlog::level::info, "Hello");
-    formatter.format(msg, formatted);
-
-    REQUIRE(to_string_view(formatted) == test_path);
-}
-
-TEST_CASE("custom flags", "[pattern_formatter]") {
-    auto formatter = std::make_shared<spdlog::pattern_formatter>();
-    formatter->add_flag<custom_test_flag>('t', "custom1")
-        .add_flag<custom_test_flag>('u', "custom2")
-        .set_pattern("[%n] [%t] [%u] %v");
-
-    memory_buf_t formatted;
-
-    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info,
-                                 "some message");
-    formatter->format(msg, formatted);
-    auto expected = spdlog::fmt_lib::format("[logger-name] [custom1] [custom2] some message{}",
-                                            spdlog::details::os::default_eol);
-
-    REQUIRE(to_string_view(formatted) == expected);
-}
-
-TEST_CASE("custom flags-padding", "[pattern_formatter]") {
-    auto formatter = std::make_shared<spdlog::pattern_formatter>();
-    formatter->add_flag<custom_test_flag>('t', "custom1")
-        .add_flag<custom_test_flag>('u', "custom2")
-        .set_pattern("[%n] [%t] [%5u] %v");
-
-    memory_buf_t formatted;
-
-    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info,
-                                 "some message");
-    formatter->format(msg, formatted);
-    auto expected = spdlog::fmt_lib::format("[logger-name] [custom1] [     custom2] some message{}",
-                                            spdlog::details::os::default_eol);
-
-    REQUIRE(to_string_view(formatted) == expected);
-}
-
-TEST_CASE("custom flags-exception", "[pattern_formatter]") {
-    auto formatter = std::make_shared<spdlog::pattern_formatter>();
-    formatter->add_flag<custom_test_flag>('t', "throw_me")
-        .add_flag<custom_test_flag>('u', "custom2")
-        .set_pattern("[%n] [%t] [%u] %v");
-
-    memory_buf_t formatted;
-    spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info,
-                                 "some message");
-    CHECK_THROWS_AS(formatter->format(msg, formatted), spdlog::spdlog_ex);
-}
-
-TEST_CASE("override need_localtime", "[pattern_formatter]") {
-    auto formatter =
-        std::make_shared<spdlog::pattern_formatter>(spdlog::pattern_time_type::local, "\n");
-    formatter->add_flag<custom_test_flag>('t', "time").set_pattern("%t> %v");
-
-    {
-        memory_buf_t formatted;
-        spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info,
-                                     "some message");
-        formatter->format(msg, formatted);
-        REQUIRE(to_string_view(formatted) == "0:00AM> some message\n");
-    }
-
-    {
-        formatter->need_localtime();
-
-        auto now_tm = spdlog::details::os::localtime();
-        std::stringstream oss;
-        oss << (now_tm.tm_hour % 12) << ":" << std::setfill('0') << std::setw(2) << now_tm.tm_min
-            << (now_tm.tm_hour / 12 ? "PM" : "AM") << "> some message\n";
-
-        memory_buf_t formatted;
-        spdlog::details::log_msg msg(spdlog::source_loc{}, "logger-name", spdlog::level::info,
-                                     "some message");
-        formatter->format(msg, formatted);
-        REQUIRE(to_string_view(formatted) == oss.str());
-    }
-}
diff --git a/Dependencies/spdlog/tests/test_registry.cpp b/Dependencies/spdlog/tests/test_registry.cpp
deleted file mode 100644
index 69ec8f53..00000000
--- a/Dependencies/spdlog/tests/test_registry.cpp
+++ /dev/null
@@ -1,112 +0,0 @@
-#include "includes.h"
-
-static const char *const tested_logger_name = "null_logger";
-static const char *const tested_logger_name2 = "null_logger2";
-
-#ifndef SPDLOG_NO_EXCEPTIONS
-TEST_CASE("register_drop", "[registry]") {
-    spdlog::drop_all();
-    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
-    REQUIRE(spdlog::get(tested_logger_name) != nullptr);
-    // Throw if registering existing name
-    REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name),
-                      spdlog::spdlog_ex);
-}
-
-TEST_CASE("explicit register", "[registry]") {
-    spdlog::drop_all();
-    auto logger = std::make_shared<spdlog::logger>(tested_logger_name,
-                                                   std::make_shared<spdlog::sinks::null_sink_st>());
-    spdlog::register_logger(logger);
-    REQUIRE(spdlog::get(tested_logger_name) != nullptr);
-    // Throw if registering existing name
-    REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name),
-                      spdlog::spdlog_ex);
-}
-#endif
-
-TEST_CASE("apply_all", "[registry]") {
-    spdlog::drop_all();
-    auto logger = std::make_shared<spdlog::logger>(tested_logger_name,
-                                                   std::make_shared<spdlog::sinks::null_sink_st>());
-    spdlog::register_logger(logger);
-    auto logger2 = std::make_shared<spdlog::logger>(
-        tested_logger_name2, std::make_shared<spdlog::sinks::null_sink_st>());
-    spdlog::register_logger(logger2);
-
-    int counter = 0;
-    spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger>) { counter++; });
-    REQUIRE(counter == 2);
-
-    counter = 0;
-    spdlog::drop(tested_logger_name2);
-    spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger> l) {
-        REQUIRE(l->name() == tested_logger_name);
-        counter++;
-    });
-    REQUIRE(counter == 1);
-}
-
-TEST_CASE("drop", "[registry]") {
-    spdlog::drop_all();
-    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
-    spdlog::drop(tested_logger_name);
-    REQUIRE_FALSE(spdlog::get(tested_logger_name));
-}
-
-TEST_CASE("drop-default", "[registry]") {
-    spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name));
-    spdlog::drop(tested_logger_name);
-    REQUIRE_FALSE(spdlog::default_logger());
-    REQUIRE_FALSE(spdlog::get(tested_logger_name));
-}
-
-TEST_CASE("drop_all", "[registry]") {
-    spdlog::drop_all();
-    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
-    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name2);
-    spdlog::drop_all();
-    REQUIRE_FALSE(spdlog::get(tested_logger_name));
-    REQUIRE_FALSE(spdlog::get(tested_logger_name2));
-    REQUIRE_FALSE(spdlog::default_logger());
-}
-
-TEST_CASE("drop non existing", "[registry]") {
-    spdlog::drop_all();
-    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
-    spdlog::drop("some_name");
-    REQUIRE_FALSE(spdlog::get("some_name"));
-    REQUIRE(spdlog::get(tested_logger_name));
-    spdlog::drop_all();
-}
-
-TEST_CASE("default logger", "[registry]") {
-    spdlog::drop_all();
-    spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name));
-    REQUIRE(spdlog::get(tested_logger_name) == spdlog::default_logger());
-    spdlog::drop_all();
-}
-
-TEST_CASE("set_default_logger(nullptr)", "[registry]") {
-    spdlog::set_default_logger(nullptr);
-    REQUIRE_FALSE(spdlog::default_logger());
-}
-
-TEST_CASE("disable automatic registration", "[registry]") {
-    // set some global parameters
-    spdlog::level::level_enum log_level = spdlog::level::level_enum::warn;
-    spdlog::set_level(log_level);
-    // but disable automatic registration
-    spdlog::set_automatic_registration(false);
-    auto logger1 = spdlog::create<spdlog::sinks::daily_file_sink_st>(
-        tested_logger_name, SPDLOG_FILENAME_T("filename"), 11, 59);
-    auto logger2 = spdlog::create_async<spdlog::sinks::stdout_color_sink_mt>(tested_logger_name2);
-    // loggers should not be part of the registry
-    REQUIRE_FALSE(spdlog::get(tested_logger_name));
-    REQUIRE_FALSE(spdlog::get(tested_logger_name2));
-    // but make sure they are still initialized according to global defaults
-    REQUIRE(logger1->level() == log_level);
-    REQUIRE(logger2->level() == log_level);
-    spdlog::set_level(spdlog::level::info);
-    spdlog::set_automatic_registration(true);
-}
diff --git a/Dependencies/spdlog/tests/test_sink.h b/Dependencies/spdlog/tests/test_sink.h
deleted file mode 100644
index 529d86dd..00000000
--- a/Dependencies/spdlog/tests/test_sink.h
+++ /dev/null
@@ -1,69 +0,0 @@
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include "spdlog/details/null_mutex.h"
-#include "spdlog/sinks/base_sink.h"
-#include "spdlog/fmt/fmt.h"
-#include <chrono>
-#include <mutex>
-#include <thread>
-
-namespace spdlog {
-namespace sinks {
-
-template <class Mutex>
-class test_sink : public base_sink<Mutex> {
-    const size_t lines_to_save = 100;
-
-public:
-    size_t msg_counter() {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        return msg_counter_;
-    }
-
-    size_t flush_counter() {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        return flush_counter_;
-    }
-
-    void set_delay(std::chrono::milliseconds delay) {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        delay_ = delay;
-    }
-
-    // return last output without the eol
-    std::vector<std::string> lines() {
-        std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
-        return lines_;
-    }
-
-protected:
-    void sink_it_(const details::log_msg &msg) override {
-        memory_buf_t formatted;
-        base_sink<Mutex>::formatter_->format(msg, formatted);
-        // save the line without the eol
-        auto eol_len = strlen(details::os::default_eol);
-        if (lines_.size() < lines_to_save) {
-            lines_.emplace_back(formatted.begin(), formatted.end() - eol_len);
-        }
-        msg_counter_++;
-        std::this_thread::sleep_for(delay_);
-    }
-
-    void flush_() override { flush_counter_++; }
-
-    size_t msg_counter_{0};
-    size_t flush_counter_{0};
-    std::chrono::milliseconds delay_{std::chrono::milliseconds::zero()};
-    std::vector<std::string> lines_;
-};
-
-using test_sink_mt = test_sink<std::mutex>;
-using test_sink_st = test_sink<details::null_mutex>;
-
-}  // namespace sinks
-}  // namespace spdlog
diff --git a/Dependencies/spdlog/tests/test_stdout_api.cpp b/Dependencies/spdlog/tests/test_stdout_api.cpp
deleted file mode 100644
index 67659b84..00000000
--- a/Dependencies/spdlog/tests/test_stdout_api.cpp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
- * This content is released under the MIT License as specified in
- * https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
- */
-#include "includes.h"
-#include "spdlog/sinks/stdout_sinks.h"
-#include "spdlog/sinks/stdout_color_sinks.h"
-TEST_CASE("stdout_st", "[stdout]") {
-    auto l = spdlog::stdout_logger_st("test");
-    l->set_pattern("%+");
-    l->set_level(spdlog::level::trace);
-    l->trace("Test stdout_st");
-    spdlog::drop_all();
-}
-
-TEST_CASE("stdout_mt", "[stdout]") {
-    auto l = spdlog::stdout_logger_mt("test");
-    l->set_pattern("%+");
-    l->set_level(spdlog::level::debug);
-    l->debug("Test stdout_mt");
-    spdlog::drop_all();
-}
-
-TEST_CASE("stderr_st", "[stderr]") {
-    auto l = spdlog::stderr_logger_st("test");
-    l->set_pattern("%+");
-    l->info("Test stderr_st");
-    spdlog::drop_all();
-}
-
-TEST_CASE("stderr_mt", "[stderr]") {
-    auto l = spdlog::stderr_logger_mt("test");
-    l->set_pattern("%+");
-    l->info("Test stderr_mt");
-    l->warn("Test stderr_mt");
-    l->error("Test stderr_mt");
-    l->critical("Test stderr_mt");
-    spdlog::drop_all();
-}
-
-// color loggers
-TEST_CASE("stdout_color_st", "[stdout]") {
-    auto l = spdlog::stdout_color_st("test");
-    l->set_pattern("%+");
-    l->info("Test stdout_color_st");
-    spdlog::drop_all();
-}
-
-TEST_CASE("stdout_color_mt", "[stdout]") {
-    auto l = spdlog::stdout_color_mt("test");
-    l->set_pattern("%+");
-    l->set_level(spdlog::level::trace);
-    l->trace("Test stdout_color_mt");
-    spdlog::drop_all();
-}
-
-TEST_CASE("stderr_color_st", "[stderr]") {
-    auto l = spdlog::stderr_color_st("test");
-    l->set_pattern("%+");
-    l->set_level(spdlog::level::debug);
-    l->debug("Test stderr_color_st");
-    spdlog::drop_all();
-}
-
-TEST_CASE("stderr_color_mt", "[stderr]") {
-    auto l = spdlog::stderr_color_mt("test");
-    l->set_pattern("%+");
-    l->info("Test stderr_color_mt");
-    l->warn("Test stderr_color_mt");
-    l->error("Test stderr_color_mt");
-    l->critical("Test stderr_color_mt");
-    spdlog::drop_all();
-}
-
-#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
-
-TEST_CASE("wchar_api", "[stdout]") {
-    auto l = spdlog::stdout_logger_st("wchar_logger");
-    l->set_pattern("%+");
-    l->set_level(spdlog::level::trace);
-    l->trace(L"Test wchar_api");
-    l->trace(L"Test wchar_api {}", L"param");
-    l->trace(L"Test wchar_api {}", 1);
-    l->trace(L"Test wchar_api {}", std::wstring{L"wstring param"});
-    l->trace(std::wstring{L"Test wchar_api wstring"});
-    SPDLOG_LOGGER_DEBUG(l, L"Test SPDLOG_LOGGER_DEBUG {}", L"param");
-    spdlog::drop_all();
-}
-
-#endif
diff --git a/Dependencies/spdlog/tests/test_stopwatch.cpp b/Dependencies/spdlog/tests/test_stopwatch.cpp
deleted file mode 100644
index b2aa246b..00000000
--- a/Dependencies/spdlog/tests/test_stopwatch.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-#include "includes.h"
-#include "test_sink.h"
-#include "spdlog/stopwatch.h"
-
-TEST_CASE("stopwatch1", "[stopwatch]") {
-    using std::chrono::milliseconds;
-    using clock = std::chrono::steady_clock;
-    milliseconds wait_ms(200);
-    milliseconds tolerance_ms(250);
-    auto start = clock::now();
-    spdlog::stopwatch sw;
-    std::this_thread::sleep_for(wait_ms);
-    auto stop = clock::now();
-    auto diff_ms = std::chrono::duration_cast<milliseconds>(stop - start);
-    REQUIRE(sw.elapsed() >= diff_ms);
-    REQUIRE(sw.elapsed() <= diff_ms + tolerance_ms);
-}
-
-TEST_CASE("stopwatch2", "[stopwatch]") {
-    using spdlog::sinks::test_sink_st;
-    using std::chrono::duration_cast;
-    using std::chrono::milliseconds;
-    using clock = std::chrono::steady_clock;
-
-    clock::duration wait_duration(milliseconds(200));
-    clock::duration tolerance_duration(milliseconds(250));
-
-    auto test_sink = std::make_shared<test_sink_st>();
-
-    auto start = clock::now();
-    spdlog::stopwatch sw;
-    spdlog::logger logger("test-stopwatch", test_sink);
-    logger.set_pattern("%v");
-    std::this_thread::sleep_for(wait_duration);
-    auto stop = clock::now();
-    logger.info("{}", sw);
-    auto val = std::stod(test_sink->lines()[0]);
-    auto diff_duration = duration_cast<std::chrono::duration<double>>(stop - start);
-
-    REQUIRE(val >= (diff_duration).count() - 0.001);
-    REQUIRE(val <= (diff_duration + tolerance_duration).count());
-}
diff --git a/Dependencies/spdlog/tests/test_systemd.cpp b/Dependencies/spdlog/tests/test_systemd.cpp
deleted file mode 100644
index e3636574..00000000
--- a/Dependencies/spdlog/tests/test_systemd.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "includes.h"
-#include "spdlog/sinks/systemd_sink.h"
-
-TEST_CASE("systemd", "[all]") {
-    auto systemd_sink = std::make_shared<spdlog::sinks::systemd_sink_st>();
-    spdlog::logger logger("spdlog_systemd_test", systemd_sink);
-    logger.set_level(spdlog::level::trace);
-    logger.trace("test spdlog trace");
-    logger.debug("test spdlog debug");
-    SPDLOG_LOGGER_INFO((&logger), "test spdlog info");
-    SPDLOG_LOGGER_WARN((&logger), "test spdlog warn");
-    SPDLOG_LOGGER_ERROR((&logger), "test spdlog error");
-    SPDLOG_LOGGER_CRITICAL((&logger), "test spdlog critical");
-}
diff --git a/Dependencies/spdlog/tests/test_time_point.cpp b/Dependencies/spdlog/tests/test_time_point.cpp
deleted file mode 100644
index b7b1b232..00000000
--- a/Dependencies/spdlog/tests/test_time_point.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "includes.h"
-#include "test_sink.h"
-#include "spdlog/async.h"
-
-TEST_CASE("time_point1", "[time_point log_msg]") {
-    std::shared_ptr<spdlog::sinks::test_sink_st> test_sink(new spdlog::sinks::test_sink_st);
-    spdlog::logger logger("test-time_point", test_sink);
-
-    spdlog::source_loc source{};
-    std::chrono::system_clock::time_point tp{std::chrono::system_clock::now()};
-    test_sink->set_pattern("%T.%F");  // interested in the time_point
-
-    // all the following should have the same time
-    test_sink->set_delay(std::chrono::milliseconds(10));
-    for (int i = 0; i < 5; i++) {
-        spdlog::details::log_msg msg{tp, source, "test_logger", spdlog::level::info, "message"};
-        test_sink->log(msg);
-    }
-
-    logger.log(tp, source, spdlog::level::info, "formatted message");
-    logger.log(tp, source, spdlog::level::info, "formatted message");
-    logger.log(tp, source, spdlog::level::info, "formatted message");
-    logger.log(tp, source, spdlog::level::info, "formatted message");
-    logger.log(source, spdlog::level::info,
-               "formatted message");  // last line has different time_point
-
-    // now the real test... that the times are the same.
-    std::vector<std::string> lines = test_sink->lines();
-    REQUIRE(lines[0] == lines[1]);
-    REQUIRE(lines[2] == lines[3]);
-    REQUIRE(lines[4] == lines[5]);
-    REQUIRE(lines[6] == lines[7]);
-    REQUIRE(lines[8] != lines[9]);
-    spdlog::drop_all();
-}
diff --git a/Dependencies/spdlog/tests/utils.cpp b/Dependencies/spdlog/tests/utils.cpp
deleted file mode 100644
index 1fa26175..00000000
--- a/Dependencies/spdlog/tests/utils.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#include "includes.h"
-
-#ifdef _WIN32
-    #include <windows.h>
-#else
-    #include <sys/types.h>
-    #include <dirent.h>
-#endif
-
-void prepare_logdir() {
-    spdlog::drop_all();
-#ifdef _WIN32
-    system("rmdir /S /Q test_logs");
-#else
-    auto rv = system("rm -rf test_logs");
-    if (rv != 0) {
-        throw std::runtime_error("Failed to rm -rf test_logs");
-    }
-#endif
-}
-
-std::string file_contents(const std::string &filename) {
-    std::ifstream ifs(filename, std::ios_base::binary);
-    if (!ifs) {
-        throw std::runtime_error("Failed open file ");
-    }
-    return std::string((std::istreambuf_iterator<char>(ifs)), (std::istreambuf_iterator<char>()));
-}
-
-std::size_t count_lines(const std::string &filename) {
-    std::ifstream ifs(filename);
-    if (!ifs) {
-        throw std::runtime_error("Failed open file ");
-    }
-
-    std::string line;
-    size_t counter = 0;
-    while (std::getline(ifs, line)) counter++;
-    return counter;
-}
-
-void require_message_count(const std::string &filename, const std::size_t messages) {
-    if (strlen(spdlog::details::os::default_eol) == 0) {
-        REQUIRE(count_lines(filename) == 1);
-    } else {
-        REQUIRE(count_lines(filename) == messages);
-    }
-}
-
-std::size_t get_filesize(const std::string &filename) {
-    std::ifstream ifs(filename, std::ifstream::ate | std::ifstream::binary);
-    if (!ifs) {
-        throw std::runtime_error("Failed open file ");
-    }
-
-    return static_cast<std::size_t>(ifs.tellg());
-}
-
-// source: https://stackoverflow.com/a/2072890/192001
-bool ends_with(std::string const &value, std::string const &ending) {
-    if (ending.size() > value.size()) {
-        return false;
-    }
-    return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
-}
-
-#ifdef _WIN32
-// Based on: https://stackoverflow.com/a/37416569/192001
-std::size_t count_files(const std::string &folder) {
-    size_t counter = 0;
-    WIN32_FIND_DATAA ffd;
-
-    // Start iterating over the files in the folder directory.
-    HANDLE hFind = ::FindFirstFileA((folder + "\\*").c_str(), &ffd);
-    if (hFind != INVALID_HANDLE_VALUE) {
-        do  // Managed to locate and create an handle to that folder.
-        {
-            if (ffd.cFileName[0] != '.') counter++;
-        } while (::FindNextFileA(hFind, &ffd) != 0);
-        ::FindClose(hFind);
-    } else {
-        throw std::runtime_error("Failed open folder " + folder);
-    }
-
-    return counter;
-}
-#else
-// Based on: https://stackoverflow.com/a/2802255/192001
-std::size_t count_files(const std::string &folder) {
-    size_t counter = 0;
-    DIR *dp = opendir(folder.c_str());
-    if (dp == nullptr) {
-        throw std::runtime_error("Failed open folder " + folder);
-    }
-
-    struct dirent *ep = nullptr;
-    while ((ep = readdir(dp)) != nullptr) {
-        if (ep->d_name[0] != '.') counter++;
-    }
-    (void)closedir(dp);
-    return counter;
-}
-#endif
diff --git a/Dependencies/spdlog/tests/utils.h b/Dependencies/spdlog/tests/utils.h
deleted file mode 100644
index 53c09b46..00000000
--- a/Dependencies/spdlog/tests/utils.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <string>
-
-std::size_t count_files(const std::string &folder);
-
-void prepare_logdir();
-
-std::string file_contents(const std::string &filename);
-
-std::size_t count_lines(const std::string &filename);
-
-void require_message_count(const std::string &filename, const std::size_t messages);
-
-std::size_t get_filesize(const std::string &filename);
-
-bool ends_with(std::string const &value, std::string const &ending);
\ No newline at end of file
diff --git a/Premake/ProjectUtil.lua b/Premake/ProjectUtil.lua
index b0fb68e1..c1681723 100644
--- a/Premake/ProjectUtil.lua
+++ b/Premake/ProjectUtil.lua
@@ -9,7 +9,7 @@ if ProjectTemplate == nil then
         _G[internalName] = { }
 
         if cppVersion == nil or cppVersion == "" then
-            cppVersion = "C++17"
+            cppVersion = "C++20"
         else
             local version = tonumber(cppVersion)
 
@@ -32,7 +32,7 @@ if ProjectTemplate == nil then
             end
 
             if not cppVersion:find("^C++") then
-                cppVersion = "C++17"
+                cppVersion = "C++20"
             end
         end
 
diff --git a/Source/Base/Base/CVarSystem/CVarSystem.h b/Source/Base/Base/CVarSystem/CVarSystem.h
index eb3027dc..1577598e 100644
--- a/Source/Base/Base/CVarSystem/CVarSystem.h
+++ b/Source/Base/Base/CVarSystem/CVarSystem.h
@@ -35,7 +35,7 @@ enum class CVarCategory : u8
 };
 DECLARE_GENERIC_BITWISE_OPERATORS(CVarCategory);
 
-constexpr char* CVarCategoryToString[u8(CVarCategory::COUNT)] =
+static const char* CVarCategoryToString[u8(CVarCategory::COUNT)] =
 {
     "Server",
     "Client",
@@ -44,7 +44,7 @@ constexpr char* CVarCategoryToString[u8(CVarCategory::COUNT)] =
     "Network",
 };
 
-constexpr char* CVarCategoryToPrefix[u8(CVarCategory::COUNT)] =
+static const char* CVarCategoryToPrefix[u8(CVarCategory::COUNT)] =
 {
     "sv_",
     "cl_",
diff --git a/Source/Base/Base/Container/ConcurrentQueue.h b/Source/Base/Base/Container/ConcurrentQueue.h
index 4b2ad791..d83417f2 100644
--- a/Source/Base/Base/Container/ConcurrentQueue.h
+++ b/Source/Base/Base/Container/ConcurrentQueue.h
@@ -81,63 +81,63 @@
 
 // Platform-specific definitions of a numeric thread ID type and an invalid value
 namespace moodycamel { namespace details {
-	template<typename thread_id_t> struct thread_id_converter {
-		typedef thread_id_t thread_id_numeric_size_t;
-		typedef thread_id_t thread_id_hash_t;
-		static thread_id_hash_t prehash(thread_id_t const& x) { return x; }
-	};
+    template<typename thread_id_t> struct thread_id_converter {
+        typedef thread_id_t thread_id_numeric_size_t;
+        typedef thread_id_t thread_id_hash_t;
+        static thread_id_hash_t prehash(thread_id_t const& x) { return x; }
+    };
 } }
 #if defined(MCDBGQ_USE_RELACY)
 namespace moodycamel { namespace details {
-	typedef std::uint32_t thread_id_t;
-	static const thread_id_t invalid_thread_id  = 0xFFFFFFFFU;
-	static const thread_id_t invalid_thread_id2 = 0xFFFFFFFEU;
-	static inline thread_id_t thread_id() { return rl::thread_index(); }
+    typedef std::uint32_t thread_id_t;
+    static const thread_id_t invalid_thread_id  = 0xFFFFFFFFU;
+    static const thread_id_t invalid_thread_id2 = 0xFFFFFFFEU;
+    static inline thread_id_t thread_id() { return rl::thread_index(); }
 } }
 #elif defined(_WIN32) || defined(__WINDOWS__) || defined(__WIN32__)
 // No sense pulling in windows.h in a header, we'll manually declare the function
 // we use and rely on backwards-compatibility for this not to break
 extern "C" __declspec(dllimport) unsigned long __stdcall GetCurrentThreadId(void);
 namespace moodycamel { namespace details {
-	static_assert(sizeof(unsigned long) == sizeof(std::uint32_t), "Expected size of unsigned long to be 32 bits on Windows");
-	typedef std::uint32_t thread_id_t;
-	static const thread_id_t invalid_thread_id  = 0;			// See http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx
-	static const thread_id_t invalid_thread_id2 = 0xFFFFFFFFU;	// Not technically guaranteed to be invalid, but is never used in practice. Note that all Win32 thread IDs are presently multiples of 4.
-	static inline thread_id_t thread_id() { return static_cast<thread_id_t>(::GetCurrentThreadId()); }
+    static_assert(sizeof(unsigned long) == sizeof(std::uint32_t), "Expected size of unsigned long to be 32 bits on Windows");
+    typedef std::uint32_t thread_id_t;
+    static const thread_id_t invalid_thread_id  = 0;			// See http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx
+    static const thread_id_t invalid_thread_id2 = 0xFFFFFFFFU;	// Not technically guaranteed to be invalid, but is never used in practice. Note that all Win32 thread IDs are presently multiples of 4.
+    static inline thread_id_t thread_id() { return static_cast<thread_id_t>(::GetCurrentThreadId()); }
 } }
 #elif defined(__arm__) || defined(_M_ARM) || defined(__aarch64__) || (defined(__APPLE__) && TARGET_OS_IPHONE) || defined(MOODYCAMEL_NO_THREAD_LOCAL)
 namespace moodycamel { namespace details {
-	static_assert(sizeof(std::thread::id) == 4 || sizeof(std::thread::id) == 8, "std::thread::id is expected to be either 4 or 8 bytes");
-	
-	typedef std::thread::id thread_id_t;
-	static const thread_id_t invalid_thread_id;         // Default ctor creates invalid ID
-
-	// Note we don't define a invalid_thread_id2 since std::thread::id doesn't have one; it's
-	// only used if MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is defined anyway, which it won't
-	// be.
-	static inline thread_id_t thread_id() { return std::this_thread::get_id(); }
-
-	template<std::size_t> struct thread_id_size { };
-	template<> struct thread_id_size<4> { typedef std::uint32_t numeric_t; };
-	template<> struct thread_id_size<8> { typedef std::uint64_t numeric_t; };
-
-	template<> struct thread_id_converter<thread_id_t> {
-		typedef thread_id_size<sizeof(thread_id_t)>::numeric_t thread_id_numeric_size_t;
+    static_assert(sizeof(std::thread::id) == 4 || sizeof(std::thread::id) == 8, "std::thread::id is expected to be either 4 or 8 bytes");
+    
+    typedef std::thread::id thread_id_t;
+    static const thread_id_t invalid_thread_id;         // Default ctor creates invalid ID
+
+    // Note we don't define a invalid_thread_id2 since std::thread::id doesn't have one; it's
+    // only used if MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is defined anyway, which it won't
+    // be.
+    static inline thread_id_t thread_id() { return std::this_thread::get_id(); }
+
+    template<std::size_t> struct thread_id_size { };
+    template<> struct thread_id_size<4> { typedef std::uint32_t numeric_t; };
+    template<> struct thread_id_size<8> { typedef std::uint64_t numeric_t; };
+
+    template<> struct thread_id_converter<thread_id_t> {
+        typedef thread_id_size<sizeof(thread_id_t)>::numeric_t thread_id_numeric_size_t;
 #ifndef __APPLE__
-		typedef std::size_t thread_id_hash_t;
+        typedef std::size_t thread_id_hash_t;
 #else
-		typedef thread_id_numeric_size_t thread_id_hash_t;
+        typedef thread_id_numeric_size_t thread_id_hash_t;
 #endif
 
-		static thread_id_hash_t prehash(thread_id_t const& x)
-		{
+        static thread_id_hash_t prehash(thread_id_t const& x)
+        {
 #ifndef __APPLE__
-			return std::hash<std::thread::id>()(x);
+            return std::hash<std::thread::id>()(x);
 #else
-			return *reinterpret_cast<thread_id_hash_t const*>(&x);
+            return *reinterpret_cast<thread_id_hash_t const*>(&x);
 #endif
-		}
-	};
+        }
+    };
 } }
 #else
 // Use a nice trick from this answer: http://stackoverflow.com/a/8438730/21475
@@ -152,10 +152,10 @@ namespace moodycamel { namespace details {
 #define MOODYCAMEL_THREADLOCAL thread_local
 #endif
 namespace moodycamel { namespace details {
-	typedef std::uintptr_t thread_id_t;
-	static const thread_id_t invalid_thread_id  = 0;		// Address can't be nullptr
-	static const thread_id_t invalid_thread_id2 = 1;		// Member accesses off a null pointer are also generally invalid. Plus it's not aligned.
-	inline thread_id_t thread_id() { static MOODYCAMEL_THREADLOCAL int x; return reinterpret_cast<thread_id_t>(&x); }
+    typedef std::uintptr_t thread_id_t;
+    static const thread_id_t invalid_thread_id  = 0;		// Address can't be nullptr
+    static const thread_id_t invalid_thread_id2 = 1;		// Member accesses off a null pointer are also generally invalid. Plus it's not aligned.
+    inline thread_id_t thread_id() { static MOODYCAMEL_THREADLOCAL int x; return reinterpret_cast<thread_id_t>(&x); }
 } }
 #endif
 
@@ -241,18 +241,18 @@ namespace moodycamel { namespace details {
 #define MOODYCAMEL_ALIGNAS(alignment) __declspec(align(alignment))
 #define MOODYCAMEL_ALIGNOF(obj) __alignof(obj)
 #define MOODYCAMEL_ALIGNED_TYPE_LIKE(T, obj) typename details::Vs2013Aligned<std::alignment_of<obj>::value, T>::type
-	template<int Align, typename T> struct Vs2013Aligned { };  // default, unsupported alignment
-	template<typename T> struct Vs2013Aligned<1, T> { typedef __declspec(align(1)) T type; };
-	template<typename T> struct Vs2013Aligned<2, T> { typedef __declspec(align(2)) T type; };
-	template<typename T> struct Vs2013Aligned<4, T> { typedef __declspec(align(4)) T type; };
-	template<typename T> struct Vs2013Aligned<8, T> { typedef __declspec(align(8)) T type; };
-	template<typename T> struct Vs2013Aligned<16, T> { typedef __declspec(align(16)) T type; };
-	template<typename T> struct Vs2013Aligned<32, T> { typedef __declspec(align(32)) T type; };
-	template<typename T> struct Vs2013Aligned<64, T> { typedef __declspec(align(64)) T type; };
-	template<typename T> struct Vs2013Aligned<128, T> { typedef __declspec(align(128)) T type; };
-	template<typename T> struct Vs2013Aligned<256, T> { typedef __declspec(align(256)) T type; };
+    template<int Align, typename T> struct Vs2013Aligned { };  // default, unsupported alignment
+    template<typename T> struct Vs2013Aligned<1, T> { typedef __declspec(align(1)) T type; };
+    template<typename T> struct Vs2013Aligned<2, T> { typedef __declspec(align(2)) T type; };
+    template<typename T> struct Vs2013Aligned<4, T> { typedef __declspec(align(4)) T type; };
+    template<typename T> struct Vs2013Aligned<8, T> { typedef __declspec(align(8)) T type; };
+    template<typename T> struct Vs2013Aligned<16, T> { typedef __declspec(align(16)) T type; };
+    template<typename T> struct Vs2013Aligned<32, T> { typedef __declspec(align(32)) T type; };
+    template<typename T> struct Vs2013Aligned<64, T> { typedef __declspec(align(64)) T type; };
+    template<typename T> struct Vs2013Aligned<128, T> { typedef __declspec(align(128)) T type; };
+    template<typename T> struct Vs2013Aligned<256, T> { typedef __declspec(align(256)) T type; };
 #else
-	template<typename T> struct identity { typedef T type; };
+    template<typename T> struct identity { typedef T type; };
 #define MOODYCAMEL_ALIGNAS(alignment) alignas(alignment)
 #define MOODYCAMEL_ALIGNOF(obj) alignof(obj)
 #define MOODYCAMEL_ALIGNED_TYPE_LIKE(T, obj) alignas(alignof(obj)) typename details::identity<T>::type
@@ -275,11 +275,11 @@ namespace moodycamel { namespace details {
 // Compiler-specific likely/unlikely hints
 namespace moodycamel { namespace details {
 #if defined(__GNUC__)
-	static inline bool (likely)(bool x) { return __builtin_expect((x), true); }
-	static inline bool (unlikely)(bool x) { return __builtin_expect((x), false); }
+    static inline bool (likely)(bool x) { return __builtin_expect((x), true); }
+    static inline bool (unlikely)(bool x) { return __builtin_expect((x), false); }
 #else
-	static inline bool (likely)(bool x) { return x; }
-	static inline bool (unlikely)(bool x) { return x; }
+    static inline bool (likely)(bool x) { return x; }
+    static inline bool (unlikely)(bool x) { return x; }
 #endif
 } }
 
@@ -289,27 +289,27 @@ namespace moodycamel { namespace details {
 
 namespace moodycamel {
 namespace details {
-	template<typename T>
-	struct const_numeric_max {
-		static_assert(std::is_integral<T>::value, "const_numeric_max can only be used with integers");
-		static const T value = std::numeric_limits<T>::is_signed
-			? (static_cast<T>(1) << (sizeof(T) * CHAR_BIT - 1)) - static_cast<T>(1)
-			: static_cast<T>(-1);
-	};
+    template<typename T>
+    struct const_numeric_max {
+        static_assert(std::is_integral<T>::value, "const_numeric_max can only be used with integers");
+        static const T value = std::numeric_limits<T>::is_signed
+            ? (static_cast<T>(1) << (sizeof(T) * CHAR_BIT - 1)) - static_cast<T>(1)
+            : static_cast<T>(-1);
+    };
 
 #if defined(__GLIBCXX__)
-	typedef ::max_align_t std_max_align_t;      // libstdc++ forgot to add it to std:: for a while
+    typedef ::max_align_t std_max_align_t;      // libstdc++ forgot to add it to std:: for a while
 #else
-	typedef std::max_align_t std_max_align_t;   // Others (e.g. MSVC) insist it can *only* be accessed via std::
+    typedef std::max_align_t std_max_align_t;   // Others (e.g. MSVC) insist it can *only* be accessed via std::
 #endif
 
-	// Some platforms have incorrectly set max_align_t to a type with <8 bytes alignment even while supporting
-	// 8-byte aligned scalar values (*cough* 32-bit iOS). Work around this with our own union. See issue #64.
-	typedef union {
-		std_max_align_t x;
-		long long y;
-		void* z;
-	} max_align_t;
+    // Some platforms have incorrectly set max_align_t to a type with <8 bytes alignment even while supporting
+    // 8-byte aligned scalar values (*cough* 32-bit iOS). Work around this with our own union. See issue #64.
+    typedef union {
+        std_max_align_t x;
+        long long y;
+        void* z;
+    } max_align_t;
 }
 
 // Default traits for the ConcurrentQueue. To change some of the
@@ -320,93 +320,93 @@ namespace details {
 // otherwise.
 struct ConcurrentQueueDefaultTraits
 {
-	// General-purpose size type. std::size_t is strongly recommended.
-	typedef std::size_t size_t;
-	
-	// The type used for the enqueue and dequeue indices. Must be at least as
-	// large as size_t. Should be significantly larger than the number of elements
-	// you expect to hold at once, especially if you have a high turnover rate;
-	// for example, on 32-bit x86, if you expect to have over a hundred million
-	// elements or pump several million elements through your queue in a very
-	// short space of time, using a 32-bit type *may* trigger a race condition.
-	// A 64-bit int type is recommended in that case, and in practice will
-	// prevent a race condition no matter the usage of the queue. Note that
-	// whether the queue is lock-free with a 64-int type depends on the whether
-	// std::atomic<std::uint64_t> is lock-free, which is platform-specific.
-	typedef std::size_t index_t;
-	
-	// Internally, all elements are enqueued and dequeued from multi-element
-	// blocks; this is the smallest controllable unit. If you expect few elements
-	// but many producers, a smaller block size should be favoured. For few producers
-	// and/or many elements, a larger block size is preferred. A sane default
-	// is provided. Must be a power of 2.
-	static const size_t BLOCK_SIZE = 32;
-	
-	// For explicit producers (i.e. when using a producer token), the block is
-	// checked for being empty by iterating through a list of flags, one per element.
-	// For large block sizes, this is too inefficient, and switching to an atomic
-	// counter-based approach is faster. The switch is made for block sizes strictly
-	// larger than this threshold.
-	static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = 32;
-	
-	// How many full blocks can be expected for a single explicit producer? This should
-	// reflect that number's maximum for optimal performance. Must be a power of 2.
-	static const size_t EXPLICIT_INITIAL_INDEX_SIZE = 32;
-	
-	// How many full blocks can be expected for a single implicit producer? This should
-	// reflect that number's maximum for optimal performance. Must be a power of 2.
-	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = 32;
-	
-	// The initial size of the hash table mapping thread IDs to implicit producers.
-	// Note that the hash is resized every time it becomes half full.
-	// Must be a power of two, and either 0 or at least 1. If 0, implicit production
-	// (using the enqueue methods without an explicit producer token) is disabled.
-	static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = 32;
-	
-	// Controls the number of items that an explicit consumer (i.e. one with a token)
-	// must consume before it causes all consumers to rotate and move on to the next
-	// internal queue.
-	static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = 256;
-	
-	// The maximum number of elements (inclusive) that can be enqueued to a sub-queue.
-	// Enqueue operations that would cause this limit to be surpassed will fail. Note
-	// that this limit is enforced at the block level (for performance reasons), i.e.
-	// it's rounded up to the nearest block size.
-	static const size_t MAX_SUBQUEUE_SIZE = details::const_numeric_max<size_t>::value;
-
-	// The number of times to spin before sleeping when waiting on a semaphore.
-	// Recommended values are on the order of 1000-10000 unless the number of
-	// consumer threads exceeds the number of idle cores (in which case try 0-100).
-	// Only affects instances of the BlockingConcurrentQueue.
-	static const int MAX_SEMA_SPINS = 10000;
-
-	// Whether to recycle dynamically-allocated blocks into an internal free list or
-	// not. If false, only pre-allocated blocks (controlled by the constructor
-	// arguments) will be recycled, and all others will be `free`d back to the heap.
-	// Note that blocks consumed by explicit producers are only freed on destruction
-	// of the queue (not following destruction of the token) regardless of this trait.
-	static const bool RECYCLE_ALLOCATED_BLOCKS = false;
-
-	
+    // General-purpose size type. std::size_t is strongly recommended.
+    typedef std::size_t size_t;
+    
+    // The type used for the enqueue and dequeue indices. Must be at least as
+    // large as size_t. Should be significantly larger than the number of elements
+    // you expect to hold at once, especially if you have a high turnover rate;
+    // for example, on 32-bit x86, if you expect to have over a hundred million
+    // elements or pump several million elements through your queue in a very
+    // short space of time, using a 32-bit type *may* trigger a race condition.
+    // A 64-bit int type is recommended in that case, and in practice will
+    // prevent a race condition no matter the usage of the queue. Note that
+    // whether the queue is lock-free with a 64-int type depends on the whether
+    // std::atomic<std::uint64_t> is lock-free, which is platform-specific.
+    typedef std::size_t index_t;
+    
+    // Internally, all elements are enqueued and dequeued from multi-element
+    // blocks; this is the smallest controllable unit. If you expect few elements
+    // but many producers, a smaller block size should be favoured. For few producers
+    // and/or many elements, a larger block size is preferred. A sane default
+    // is provided. Must be a power of 2.
+    static const size_t BLOCK_SIZE = 32;
+    
+    // For explicit producers (i.e. when using a producer token), the block is
+    // checked for being empty by iterating through a list of flags, one per element.
+    // For large block sizes, this is too inefficient, and switching to an atomic
+    // counter-based approach is faster. The switch is made for block sizes strictly
+    // larger than this threshold.
+    static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = 32;
+    
+    // How many full blocks can be expected for a single explicit producer? This should
+    // reflect that number's maximum for optimal performance. Must be a power of 2.
+    static const size_t EXPLICIT_INITIAL_INDEX_SIZE = 32;
+    
+    // How many full blocks can be expected for a single implicit producer? This should
+    // reflect that number's maximum for optimal performance. Must be a power of 2.
+    static const size_t IMPLICIT_INITIAL_INDEX_SIZE = 32;
+    
+    // The initial size of the hash table mapping thread IDs to implicit producers.
+    // Note that the hash is resized every time it becomes half full.
+    // Must be a power of two, and either 0 or at least 1. If 0, implicit production
+    // (using the enqueue methods without an explicit producer token) is disabled.
+    static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = 32;
+    
+    // Controls the number of items that an explicit consumer (i.e. one with a token)
+    // must consume before it causes all consumers to rotate and move on to the next
+    // internal queue.
+    static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = 256;
+    
+    // The maximum number of elements (inclusive) that can be enqueued to a sub-queue.
+    // Enqueue operations that would cause this limit to be surpassed will fail. Note
+    // that this limit is enforced at the block level (for performance reasons), i.e.
+    // it's rounded up to the nearest block size.
+    static const size_t MAX_SUBQUEUE_SIZE = details::const_numeric_max<size_t>::value;
+
+    // The number of times to spin before sleeping when waiting on a semaphore.
+    // Recommended values are on the order of 1000-10000 unless the number of
+    // consumer threads exceeds the number of idle cores (in which case try 0-100).
+    // Only affects instances of the BlockingConcurrentQueue.
+    static const int MAX_SEMA_SPINS = 10000;
+
+    // Whether to recycle dynamically-allocated blocks into an internal free list or
+    // not. If false, only pre-allocated blocks (controlled by the constructor
+    // arguments) will be recycled, and all others will be `free`d back to the heap.
+    // Note that blocks consumed by explicit producers are only freed on destruction
+    // of the queue (not following destruction of the token) regardless of this trait.
+    static const bool RECYCLE_ALLOCATED_BLOCKS = false;
+
+    
 #ifndef MCDBGQ_USE_RELACY
-	// Memory allocation can be customized if needed.
-	// malloc should return nullptr on failure, and handle alignment like std::malloc.
+    // Memory allocation can be customized if needed.
+    // malloc should return nullptr on failure, and handle alignment like std::malloc.
 #if defined(malloc) || defined(free)
-	// Gah, this is 2015, stop defining macros that break standard code already!
-	// Work around malloc/free being special macros:
-	static inline void* WORKAROUND_malloc(size_t size) { return malloc(size); }
-	static inline void WORKAROUND_free(void* ptr) { return free(ptr); }
-	static inline void* (malloc)(size_t size) { return WORKAROUND_malloc(size); }
-	static inline void (free)(void* ptr) { return WORKAROUND_free(ptr); }
+    // Gah, this is 2015, stop defining macros that break standard code already!
+    // Work around malloc/free being special macros:
+    static inline void* WORKAROUND_malloc(size_t size) { return malloc(size); }
+    static inline void WORKAROUND_free(void* ptr) { return free(ptr); }
+    static inline void* (malloc)(size_t size) { return WORKAROUND_malloc(size); }
+    static inline void (free)(void* ptr) { return WORKAROUND_free(ptr); }
 #else
-	static inline void* malloc(size_t size) { return std::malloc(size); }
-	static inline void free(void* ptr) { return std::free(ptr); }
+    static inline void* malloc(size_t size) { return std::malloc(size); }
+    static inline void free(void* ptr) { return std::free(ptr); }
 #endif
 #else
-	// Debug versions when running under the Relacy race detector (ignore
-	// these in user code)
-	static inline void* malloc(size_t size) { return rl::rl_malloc(size, $); }
-	static inline void free(void* ptr) { return rl::rl_free(ptr, $); }
+    // Debug versions when running under the Relacy race detector (ignore
+    // these in user code)
+    static inline void* malloc(size_t size) { return rl::rl_malloc(size, $); }
+    static inline void free(void* ptr) { return rl::rl_free(ptr, $); }
 #endif
 };
 
@@ -428,333 +428,333 @@ class ConcurrentQueueTests;
 
 namespace details
 {
-	struct ConcurrentQueueProducerTypelessBase
-	{
-		ConcurrentQueueProducerTypelessBase* next;
-		std::atomic<bool> inactive;
-		ProducerToken* token;
-		
-		ConcurrentQueueProducerTypelessBase()
-			: next(nullptr), inactive(false), token(nullptr)
-		{
-		}
-	};
-	
-	template<bool use32> struct _hash_32_or_64 {
-		static inline std::uint32_t hash(std::uint32_t h)
-		{
-			// MurmurHash3 finalizer -- see https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
-			// Since the thread ID is already unique, all we really want to do is propagate that
-			// uniqueness evenly across all the bits, so that we can use a subset of the bits while
-			// reducing collisions significantly
-			h ^= h >> 16;
-			h *= 0x85ebca6b;
-			h ^= h >> 13;
-			h *= 0xc2b2ae35;
-			return h ^ (h >> 16);
-		}
-	};
-	template<> struct _hash_32_or_64<1> {
-		static inline std::uint64_t hash(std::uint64_t h)
-		{
-			h ^= h >> 33;
-			h *= 0xff51afd7ed558ccd;
-			h ^= h >> 33;
-			h *= 0xc4ceb9fe1a85ec53;
-			return h ^ (h >> 33);
-		}
-	};
-	template<std::size_t size> struct hash_32_or_64 : public _hash_32_or_64<(size > 4)> {  };
-	
-	static inline size_t hash_thread_id(thread_id_t id)
-	{
-		static_assert(sizeof(thread_id_t) <= 8, "Expected a platform where thread IDs are at most 64-bit values");
-		return static_cast<size_t>(hash_32_or_64<sizeof(thread_id_converter<thread_id_t>::thread_id_hash_t)>::hash(
-			thread_id_converter<thread_id_t>::prehash(id)));
-	}
-	
-	template<typename T>
-	static inline bool circular_less_than(T a, T b)
-	{
-		static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "circular_less_than is intended to be used only with unsigned integer types");
-		return static_cast<T>(a - b) > static_cast<T>(static_cast<T>(1) << (static_cast<T>(sizeof(T) * CHAR_BIT - 1)));
-		// Note: extra parens around rhs of operator<< is MSVC bug: https://developercommunity2.visualstudio.com/t/C4554-triggers-when-both-lhs-and-rhs-is/10034931
-		//       silencing the bug requires #pragma warning(disable: 4554) around the calling code and has no effect when done here.
-	}
-	
-	template<typename U>
-	static inline char* align_for(char* ptr)
-	{
-		const std::size_t alignment = std::alignment_of<U>::value;
-		return ptr + (alignment - (reinterpret_cast<std::uintptr_t>(ptr) % alignment)) % alignment;
-	}
-
-	template<typename T>
-	static inline T ceil_to_pow_2(T x)
-	{
-		static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "ceil_to_pow_2 is intended to be used only with unsigned integer types");
-
-		// Adapted from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-		--x;
-		x |= x >> 1;
-		x |= x >> 2;
-		x |= x >> 4;
-		for (std::size_t i = 1; i < sizeof(T); i <<= 1) {
-			x |= x >> (i << 3);
-		}
-		++x;
-		return x;
-	}
-	
-	template<typename T>
-	static inline void swap_relaxed(std::atomic<T>& left, std::atomic<T>& right)
-	{
-		T temp = std::move(left.load(std::memory_order_relaxed));
-		left.store(std::move(right.load(std::memory_order_relaxed)), std::memory_order_relaxed);
-		right.store(std::move(temp), std::memory_order_relaxed);
-	}
-	
-	template<typename T>
-	static inline T const& nomove(T const& x)
-	{
-		return x;
-	}
-	
-	template<bool Enable>
-	struct nomove_if
-	{
-		template<typename T>
-		static inline T const& eval(T const& x)
-		{
-			return x;
-		}
-	};
-	
-	template<>
-	struct nomove_if<false>
-	{
-		template<typename U>
-		static inline auto eval(U&& x)
-			-> decltype(std::forward<U>(x))
-		{
-			return std::forward<U>(x);
-		}
-	};
-	
-	template<typename It>
-	static inline auto deref_noexcept(It& it) MOODYCAMEL_NOEXCEPT -> decltype(*it)
-	{
-		return *it;
-	}
-	
+    struct ConcurrentQueueProducerTypelessBase
+    {
+        ConcurrentQueueProducerTypelessBase* next;
+        std::atomic<bool> inactive;
+        ProducerToken* token;
+        
+        ConcurrentQueueProducerTypelessBase()
+            : next(nullptr), inactive(false), token(nullptr)
+        {
+        }
+    };
+    
+    template<bool use32> struct _hash_32_or_64 {
+        static inline std::uint32_t hash(std::uint32_t h)
+        {
+            // MurmurHash3 finalizer -- see https://code.google.com/p/smhasher/source/browse/trunk/MurmurHash3.cpp
+            // Since the thread ID is already unique, all we really want to do is propagate that
+            // uniqueness evenly across all the bits, so that we can use a subset of the bits while
+            // reducing collisions significantly
+            h ^= h >> 16;
+            h *= 0x85ebca6b;
+            h ^= h >> 13;
+            h *= 0xc2b2ae35;
+            return h ^ (h >> 16);
+        }
+    };
+    template<> struct _hash_32_or_64<1> {
+        static inline std::uint64_t hash(std::uint64_t h)
+        {
+            h ^= h >> 33;
+            h *= 0xff51afd7ed558ccd;
+            h ^= h >> 33;
+            h *= 0xc4ceb9fe1a85ec53;
+            return h ^ (h >> 33);
+        }
+    };
+    template<std::size_t size> struct hash_32_or_64 : public _hash_32_or_64<(size > 4)> {  };
+    
+    static inline size_t hash_thread_id(thread_id_t id)
+    {
+        static_assert(sizeof(thread_id_t) <= 8, "Expected a platform where thread IDs are at most 64-bit values");
+        return static_cast<size_t>(hash_32_or_64<sizeof(thread_id_converter<thread_id_t>::thread_id_hash_t)>::hash(
+            thread_id_converter<thread_id_t>::prehash(id)));
+    }
+    
+    template<typename T>
+    static inline bool circular_less_than(T a, T b)
+    {
+        static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "circular_less_than is intended to be used only with unsigned integer types");
+        return static_cast<T>(a - b) > static_cast<T>(static_cast<T>(1) << (static_cast<T>(sizeof(T) * CHAR_BIT - 1)));
+        // Note: extra parens around rhs of operator<< is MSVC bug: https://developercommunity2.visualstudio.com/t/C4554-triggers-when-both-lhs-and-rhs-is/10034931
+        //       silencing the bug requires #pragma warning(disable: 4554) around the calling code and has no effect when done here.
+    }
+    
+    template<typename U>
+    static inline char* align_for(char* ptr)
+    {
+        const std::size_t alignment = std::alignment_of<U>::value;
+        return ptr + (alignment - (reinterpret_cast<std::uintptr_t>(ptr) % alignment)) % alignment;
+    }
+
+    template<typename T>
+    static inline T ceil_to_pow_2(T x)
+    {
+        static_assert(std::is_integral<T>::value && !std::numeric_limits<T>::is_signed, "ceil_to_pow_2 is intended to be used only with unsigned integer types");
+
+        // Adapted from http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+        --x;
+        x |= x >> 1;
+        x |= x >> 2;
+        x |= x >> 4;
+        for (std::size_t i = 1; i < sizeof(T); i <<= 1) {
+            x |= x >> (i << 3);
+        }
+        ++x;
+        return x;
+    }
+    
+    template<typename T>
+    static inline void swap_relaxed(std::atomic<T>& left, std::atomic<T>& right)
+    {
+        T temp = std::move(left.load(std::memory_order_relaxed));
+        left.store(std::move(right.load(std::memory_order_relaxed)), std::memory_order_relaxed);
+        right.store(std::move(temp), std::memory_order_relaxed);
+    }
+    
+    template<typename T>
+    static inline T const& nomove(T const& x)
+    {
+        return x;
+    }
+    
+    template<bool Enable>
+    struct nomove_if
+    {
+        template<typename T>
+        static inline T const& eval(T const& x)
+        {
+            return x;
+        }
+    };
+    
+    template<>
+    struct nomove_if<false>
+    {
+        template<typename U>
+        static inline auto eval(U&& x)
+            -> decltype(std::forward<U>(x))
+        {
+            return std::forward<U>(x);
+        }
+    };
+    
+    template<typename It>
+    static inline auto deref_noexcept(It& it) MOODYCAMEL_NOEXCEPT -> decltype(*it)
+    {
+        return *it;
+    }
+    
 #if defined(__clang__) || !defined(__GNUC__) || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
-	template<typename T> struct is_trivially_destructible : std::is_trivially_destructible<T> { };
+    template<typename T> struct is_trivially_destructible : std::is_trivially_destructible<T> { };
 #else
-	template<typename T> struct is_trivially_destructible : std::has_trivial_destructor<T> { };
+    template<typename T> struct is_trivially_destructible : std::has_trivial_destructor<T> { };
 #endif
-	
+    
 #ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
 #ifdef MCDBGQ_USE_RELACY
-	typedef RelacyThreadExitListener ThreadExitListener;
-	typedef RelacyThreadExitNotifier ThreadExitNotifier;
+    typedef RelacyThreadExitListener ThreadExitListener;
+    typedef RelacyThreadExitNotifier ThreadExitNotifier;
 #else
-	class ThreadExitNotifier;
-
-	struct ThreadExitListener
-	{
-		typedef void (*callback_t)(void*);
-		callback_t callback;
-		void* userData;
-		
-		ThreadExitListener* next;		// reserved for use by the ThreadExitNotifier
-		ThreadExitNotifier* chain;		// reserved for use by the ThreadExitNotifier
-	};
-
-	class ThreadExitNotifier
-	{
-	public:
-		static void subscribe(ThreadExitListener* listener)
-		{
-			auto& tlsInst = instance();
-			std::lock_guard<std::mutex> guard(mutex());
-			listener->next = tlsInst.tail;
-			listener->chain = &tlsInst;
-			tlsInst.tail = listener;
-		}
-		
-		static void unsubscribe(ThreadExitListener* listener)
-		{
-			std::lock_guard<std::mutex> guard(mutex());
-			if (!listener->chain) {
-				return;  // race with ~ThreadExitNotifier
-			}
-			auto& tlsInst = *listener->chain;
-			listener->chain = nullptr;
-			ThreadExitListener** prev = &tlsInst.tail;
-			for (auto ptr = tlsInst.tail; ptr != nullptr; ptr = ptr->next) {
-				if (ptr == listener) {
-					*prev = ptr->next;
-					break;
-				}
-				prev = &ptr->next;
-			}
-		}
-		
-	private:
-		ThreadExitNotifier() : tail(nullptr) { }
-		ThreadExitNotifier(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
-		ThreadExitNotifier& operator=(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
-		
-		~ThreadExitNotifier()
-		{
-			// This thread is about to exit, let everyone know!
-			assert(this == &instance() && "If this assert fails, you likely have a buggy compiler! Change the preprocessor conditions such that MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is no longer defined.");
-			std::lock_guard<std::mutex> guard(mutex());
-			for (auto ptr = tail; ptr != nullptr; ptr = ptr->next) {
-				ptr->chain = nullptr;
-				ptr->callback(ptr->userData);
-			}
-		}
-		
-		// Thread-local
-		static inline ThreadExitNotifier& instance()
-		{
-			static thread_local ThreadExitNotifier notifier;
-			return notifier;
-		}
-
-		static inline std::mutex& mutex()
-		{
-			// Must be static because the ThreadExitNotifier could be destroyed while unsubscribe is called
-			static std::mutex mutex;
-			return mutex;
-		}
-		
-	private:
-		ThreadExitListener* tail;
-	};
-#endif
-#endif
-	
-	template<typename T> struct static_is_lock_free_num { enum { value = 0 }; };
-	template<> struct static_is_lock_free_num<signed char> { enum { value = ATOMIC_CHAR_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<short> { enum { value = ATOMIC_SHORT_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<int> { enum { value = ATOMIC_INT_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<long> { enum { value = ATOMIC_LONG_LOCK_FREE }; };
-	template<> struct static_is_lock_free_num<long long> { enum { value = ATOMIC_LLONG_LOCK_FREE }; };
-	template<typename T> struct static_is_lock_free : static_is_lock_free_num<typename std::make_signed<T>::type> {  };
-	template<> struct static_is_lock_free<bool> { enum { value = ATOMIC_BOOL_LOCK_FREE }; };
-	template<typename U> struct static_is_lock_free<U*> { enum { value = ATOMIC_POINTER_LOCK_FREE }; };
+    class ThreadExitNotifier;
+
+    struct ThreadExitListener
+    {
+        typedef void (*callback_t)(void*);
+        callback_t callback;
+        void* userData;
+        
+        ThreadExitListener* next;		// reserved for use by the ThreadExitNotifier
+        ThreadExitNotifier* chain;		// reserved for use by the ThreadExitNotifier
+    };
+
+    class ThreadExitNotifier
+    {
+    public:
+        static void subscribe(ThreadExitListener* listener)
+        {
+            auto& tlsInst = instance();
+            std::lock_guard<std::mutex> guard(mutex());
+            listener->next = tlsInst.tail;
+            listener->chain = &tlsInst;
+            tlsInst.tail = listener;
+        }
+        
+        static void unsubscribe(ThreadExitListener* listener)
+        {
+            std::lock_guard<std::mutex> guard(mutex());
+            if (!listener->chain) {
+                return;  // race with ~ThreadExitNotifier
+            }
+            auto& tlsInst = *listener->chain;
+            listener->chain = nullptr;
+            ThreadExitListener** prev = &tlsInst.tail;
+            for (auto ptr = tlsInst.tail; ptr != nullptr; ptr = ptr->next) {
+                if (ptr == listener) {
+                    *prev = ptr->next;
+                    break;
+                }
+                prev = &ptr->next;
+            }
+        }
+        
+    private:
+        ThreadExitNotifier() : tail(nullptr) { }
+        ThreadExitNotifier(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
+        ThreadExitNotifier& operator=(ThreadExitNotifier const&) MOODYCAMEL_DELETE_FUNCTION;
+        
+        ~ThreadExitNotifier()
+        {
+            // This thread is about to exit, let everyone know!
+            assert(this == &instance() && "If this assert fails, you likely have a buggy compiler! Change the preprocessor conditions such that MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED is no longer defined.");
+            std::lock_guard<std::mutex> guard(mutex());
+            for (auto ptr = tail; ptr != nullptr; ptr = ptr->next) {
+                ptr->chain = nullptr;
+                ptr->callback(ptr->userData);
+            }
+        }
+        
+        // Thread-local
+        static inline ThreadExitNotifier& instance()
+        {
+            static thread_local ThreadExitNotifier notifier;
+            return notifier;
+        }
+
+        static inline std::mutex& mutex()
+        {
+            // Must be static because the ThreadExitNotifier could be destroyed while unsubscribe is called
+            static std::mutex mutex;
+            return mutex;
+        }
+        
+    private:
+        ThreadExitListener* tail;
+    };
+#endif
+#endif
+    
+    template<typename T> struct static_is_lock_free_num { enum { value = 0 }; };
+    template<> struct static_is_lock_free_num<signed char> { enum { value = ATOMIC_CHAR_LOCK_FREE }; };
+    template<> struct static_is_lock_free_num<short> { enum { value = ATOMIC_SHORT_LOCK_FREE }; };
+    template<> struct static_is_lock_free_num<int> { enum { value = ATOMIC_INT_LOCK_FREE }; };
+    template<> struct static_is_lock_free_num<long> { enum { value = ATOMIC_LONG_LOCK_FREE }; };
+    template<> struct static_is_lock_free_num<long long> { enum { value = ATOMIC_LLONG_LOCK_FREE }; };
+    template<typename T> struct static_is_lock_free : static_is_lock_free_num<typename std::make_signed<T>::type> {  };
+    template<> struct static_is_lock_free<bool> { enum { value = ATOMIC_BOOL_LOCK_FREE }; };
+    template<typename U> struct static_is_lock_free<U*> { enum { value = ATOMIC_POINTER_LOCK_FREE }; };
 }
 
 
 struct ProducerToken
 {
-	template<typename T, typename Traits>
-	explicit ProducerToken(ConcurrentQueue<T, Traits>& queue);
-	
-	template<typename T, typename Traits>
-	explicit ProducerToken(BlockingConcurrentQueue<T, Traits>& queue);
-	
-	ProducerToken(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
-		: producer(other.producer)
-	{
-		other.producer = nullptr;
-		if (producer != nullptr) {
-			producer->token = this;
-		}
-	}
-	
-	inline ProducerToken& operator=(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
-	{
-		swap(other);
-		return *this;
-	}
-	
-	void swap(ProducerToken& other) MOODYCAMEL_NOEXCEPT
-	{
-		std::swap(producer, other.producer);
-		if (producer != nullptr) {
-			producer->token = this;
-		}
-		if (other.producer != nullptr) {
-			other.producer->token = &other;
-		}
-	}
-	
-	// A token is always valid unless:
-	//     1) Memory allocation failed during construction
-	//     2) It was moved via the move constructor
-	//        (Note: assignment does a swap, leaving both potentially valid)
-	//     3) The associated queue was destroyed
-	// Note that if valid() returns true, that only indicates
-	// that the token is valid for use with a specific queue,
-	// but not which one; that's up to the user to track.
-	inline bool valid() const { return producer != nullptr; }
-	
-	~ProducerToken()
-	{
-		if (producer != nullptr) {
-			producer->token = nullptr;
-			producer->inactive.store(true, std::memory_order_release);
-		}
-	}
-	
-	// Disable copying and assignment
-	ProducerToken(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-	ProducerToken& operator=(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-	
+    template<typename T, typename Traits>
+    explicit ProducerToken(ConcurrentQueue<T, Traits>& queue);
+    
+    template<typename T, typename Traits>
+    explicit ProducerToken(BlockingConcurrentQueue<T, Traits>& queue);
+    
+    ProducerToken(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
+        : producer(other.producer)
+    {
+        other.producer = nullptr;
+        if (producer != nullptr) {
+            producer->token = this;
+        }
+    }
+    
+    inline ProducerToken& operator=(ProducerToken&& other) MOODYCAMEL_NOEXCEPT
+    {
+        swap(other);
+        return *this;
+    }
+    
+    void swap(ProducerToken& other) MOODYCAMEL_NOEXCEPT
+    {
+        std::swap(producer, other.producer);
+        if (producer != nullptr) {
+            producer->token = this;
+        }
+        if (other.producer != nullptr) {
+            other.producer->token = &other;
+        }
+    }
+    
+    // A token is always valid unless:
+    //     1) Memory allocation failed during construction
+    //     2) It was moved via the move constructor
+    //        (Note: assignment does a swap, leaving both potentially valid)
+    //     3) The associated queue was destroyed
+    // Note that if valid() returns true, that only indicates
+    // that the token is valid for use with a specific queue,
+    // but not which one; that's up to the user to track.
+    inline bool valid() const { return producer != nullptr; }
+    
+    ~ProducerToken()
+    {
+        if (producer != nullptr) {
+            producer->token = nullptr;
+            producer->inactive.store(true, std::memory_order_release);
+        }
+    }
+    
+    // Disable copying and assignment
+    ProducerToken(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
+    ProducerToken& operator=(ProducerToken const&) MOODYCAMEL_DELETE_FUNCTION;
+    
 private:
-	template<typename T, typename Traits> friend class ConcurrentQueue;
-	friend class ConcurrentQueueTests;
-	
+    template<typename T, typename Traits> friend class ConcurrentQueue;
+    friend class ConcurrentQueueTests;
+    
 protected:
-	details::ConcurrentQueueProducerTypelessBase* producer;
+    details::ConcurrentQueueProducerTypelessBase* producer;
 };
 
 
 struct ConsumerToken
 {
-	template<typename T, typename Traits>
-	explicit ConsumerToken(ConcurrentQueue<T, Traits>& q);
-	
-	template<typename T, typename Traits>
-	explicit ConsumerToken(BlockingConcurrentQueue<T, Traits>& q);
-	
-	ConsumerToken(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
-		: initialOffset(other.initialOffset), lastKnownGlobalOffset(other.lastKnownGlobalOffset), itemsConsumedFromCurrent(other.itemsConsumedFromCurrent), currentProducer(other.currentProducer), desiredProducer(other.desiredProducer)
-	{
-	}
-	
-	inline ConsumerToken& operator=(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
-	{
-		swap(other);
-		return *this;
-	}
-	
-	void swap(ConsumerToken& other) MOODYCAMEL_NOEXCEPT
-	{
-		std::swap(initialOffset, other.initialOffset);
-		std::swap(lastKnownGlobalOffset, other.lastKnownGlobalOffset);
-		std::swap(itemsConsumedFromCurrent, other.itemsConsumedFromCurrent);
-		std::swap(currentProducer, other.currentProducer);
-		std::swap(desiredProducer, other.desiredProducer);
-	}
-	
-	// Disable copying and assignment
-	ConsumerToken(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
-	ConsumerToken& operator=(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
+    template<typename T, typename Traits>
+    explicit ConsumerToken(ConcurrentQueue<T, Traits>& q);
+    
+    template<typename T, typename Traits>
+    explicit ConsumerToken(BlockingConcurrentQueue<T, Traits>& q);
+    
+    ConsumerToken(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
+        : initialOffset(other.initialOffset), lastKnownGlobalOffset(other.lastKnownGlobalOffset), itemsConsumedFromCurrent(other.itemsConsumedFromCurrent), currentProducer(other.currentProducer), desiredProducer(other.desiredProducer)
+    {
+    }
+    
+    inline ConsumerToken& operator=(ConsumerToken&& other) MOODYCAMEL_NOEXCEPT
+    {
+        swap(other);
+        return *this;
+    }
+    
+    void swap(ConsumerToken& other) MOODYCAMEL_NOEXCEPT
+    {
+        std::swap(initialOffset, other.initialOffset);
+        std::swap(lastKnownGlobalOffset, other.lastKnownGlobalOffset);
+        std::swap(itemsConsumedFromCurrent, other.itemsConsumedFromCurrent);
+        std::swap(currentProducer, other.currentProducer);
+        std::swap(desiredProducer, other.desiredProducer);
+    }
+    
+    // Disable copying and assignment
+    ConsumerToken(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
+    ConsumerToken& operator=(ConsumerToken const&) MOODYCAMEL_DELETE_FUNCTION;
 
 private:
-	template<typename T, typename Traits> friend class ConcurrentQueue;
-	friend class ConcurrentQueueTests;
-	
+    template<typename T, typename Traits> friend class ConcurrentQueue;
+    friend class ConcurrentQueueTests;
+    
 private: // but shared with ConcurrentQueue
-	std::uint32_t initialOffset;
-	std::uint32_t lastKnownGlobalOffset;
-	std::uint32_t itemsConsumedFromCurrent;
-	details::ConcurrentQueueProducerTypelessBase* currentProducer;
-	details::ConcurrentQueueProducerTypelessBase* desiredProducer;
+    std::uint32_t initialOffset;
+    std::uint32_t lastKnownGlobalOffset;
+    std::uint32_t itemsConsumedFromCurrent;
+    details::ConcurrentQueueProducerTypelessBase* currentProducer;
+    details::ConcurrentQueueProducerTypelessBase* desiredProducer;
 };
 
 // Need to forward-declare this swap because it's in a namespace.
@@ -767,2973 +767,2973 @@ template<typename T, typename Traits = ConcurrentQueueDefaultTraits>
 class ConcurrentQueue
 {
 public:
-	typedef ::moodycamel::ProducerToken producer_token_t;
-	typedef ::moodycamel::ConsumerToken consumer_token_t;
-	
-	typedef typename Traits::index_t index_t;
-	typedef typename Traits::size_t size_t;
-	
-	static const size_t BLOCK_SIZE = static_cast<size_t>(Traits::BLOCK_SIZE);
-	static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = static_cast<size_t>(Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD);
-	static const size_t EXPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::EXPLICIT_INITIAL_INDEX_SIZE);
-	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::IMPLICIT_INITIAL_INDEX_SIZE);
-	static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = static_cast<size_t>(Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE);
-	static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = static_cast<std::uint32_t>(Traits::EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE);
+    typedef ::moodycamel::ProducerToken producer_token_t;
+    typedef ::moodycamel::ConsumerToken consumer_token_t;
+    
+    typedef typename Traits::index_t index_t;
+    typedef typename Traits::size_t size_t;
+    
+    static const size_t BLOCK_SIZE = static_cast<size_t>(Traits::BLOCK_SIZE);
+    static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = static_cast<size_t>(Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD);
+    static const size_t EXPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::EXPLICIT_INITIAL_INDEX_SIZE);
+    static const size_t IMPLICIT_INITIAL_INDEX_SIZE = static_cast<size_t>(Traits::IMPLICIT_INITIAL_INDEX_SIZE);
+    static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = static_cast<size_t>(Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE);
+    static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = static_cast<std::uint32_t>(Traits::EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE);
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable: 4307)		// + integral constant overflow (that's what the ternary expression is for!)
 #pragma warning(disable: 4309)		// static_cast: Truncation of constant value
 #endif
-	static const size_t MAX_SUBQUEUE_SIZE = (details::const_numeric_max<size_t>::value - static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) < BLOCK_SIZE) ? details::const_numeric_max<size_t>::value : ((static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) + (BLOCK_SIZE - 1)) / BLOCK_SIZE * BLOCK_SIZE);
+    static const size_t MAX_SUBQUEUE_SIZE = (details::const_numeric_max<size_t>::value - static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) < BLOCK_SIZE) ? details::const_numeric_max<size_t>::value : ((static_cast<size_t>(Traits::MAX_SUBQUEUE_SIZE) + (BLOCK_SIZE - 1)) / BLOCK_SIZE * BLOCK_SIZE);
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
 
-	static_assert(!std::numeric_limits<size_t>::is_signed && std::is_integral<size_t>::value, "Traits::size_t must be an unsigned integral type");
-	static_assert(!std::numeric_limits<index_t>::is_signed && std::is_integral<index_t>::value, "Traits::index_t must be an unsigned integral type");
-	static_assert(sizeof(index_t) >= sizeof(size_t), "Traits::index_t must be at least as wide as Traits::size_t");
-	static_assert((BLOCK_SIZE > 1) && !(BLOCK_SIZE & (BLOCK_SIZE - 1)), "Traits::BLOCK_SIZE must be a power of 2 (and at least 2)");
-	static_assert((EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD > 1) && !(EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD & (EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD - 1)), "Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD must be a power of 2 (and greater than 1)");
-	static_assert((EXPLICIT_INITIAL_INDEX_SIZE > 1) && !(EXPLICIT_INITIAL_INDEX_SIZE & (EXPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::EXPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
-	static_assert((IMPLICIT_INITIAL_INDEX_SIZE > 1) && !(IMPLICIT_INITIAL_INDEX_SIZE & (IMPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::IMPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
-	static_assert((INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) || !(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE & (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE - 1)), "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be a power of 2");
-	static_assert(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0 || INITIAL_IMPLICIT_PRODUCER_HASH_SIZE >= 1, "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be at least 1 (or 0 to disable implicit enqueueing)");
+    static_assert(!std::numeric_limits<size_t>::is_signed && std::is_integral<size_t>::value, "Traits::size_t must be an unsigned integral type");
+    static_assert(!std::numeric_limits<index_t>::is_signed && std::is_integral<index_t>::value, "Traits::index_t must be an unsigned integral type");
+    static_assert(sizeof(index_t) >= sizeof(size_t), "Traits::index_t must be at least as wide as Traits::size_t");
+    static_assert((BLOCK_SIZE > 1) && !(BLOCK_SIZE & (BLOCK_SIZE - 1)), "Traits::BLOCK_SIZE must be a power of 2 (and at least 2)");
+    static_assert((EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD > 1) && !(EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD & (EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD - 1)), "Traits::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD must be a power of 2 (and greater than 1)");
+    static_assert((EXPLICIT_INITIAL_INDEX_SIZE > 1) && !(EXPLICIT_INITIAL_INDEX_SIZE & (EXPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::EXPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
+    static_assert((IMPLICIT_INITIAL_INDEX_SIZE > 1) && !(IMPLICIT_INITIAL_INDEX_SIZE & (IMPLICIT_INITIAL_INDEX_SIZE - 1)), "Traits::IMPLICIT_INITIAL_INDEX_SIZE must be a power of 2 (and greater than 1)");
+    static_assert((INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) || !(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE & (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE - 1)), "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be a power of 2");
+    static_assert(INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0 || INITIAL_IMPLICIT_PRODUCER_HASH_SIZE >= 1, "Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE must be at least 1 (or 0 to disable implicit enqueueing)");
 
 public:
-	// Creates a queue with at least `capacity` element slots; note that the
-	// actual number of elements that can be inserted without additional memory
-	// allocation depends on the number of producers and the block size (e.g. if
-	// the block size is equal to `capacity`, only a single block will be allocated
-	// up-front, which means only a single producer will be able to enqueue elements
-	// without an extra allocation -- blocks aren't shared between producers).
-	// This method is not thread safe -- it is up to the user to ensure that the
-	// queue is fully constructed before it starts being used by other threads (this
-	// includes making the memory effects of construction visible, possibly with a
-	// memory barrier).
-	explicit ConcurrentQueue(size_t capacity = 32 * BLOCK_SIZE)
-		: producerListTail(nullptr),
-		producerCount(0),
-		initialBlockPoolIndex(0),
-		nextExplicitConsumerId(0),
-		globalExplicitConsumerOffset(0)
-	{
-		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-		populate_initial_implicit_producer_hash();
-		populate_initial_block_list(capacity / BLOCK_SIZE + ((capacity & (BLOCK_SIZE - 1)) == 0 ? 0 : 1));
-		
+    // Creates a queue with at least `capacity` element slots; note that the
+    // actual number of elements that can be inserted without additional memory
+    // allocation depends on the number of producers and the block size (e.g. if
+    // the block size is equal to `capacity`, only a single block will be allocated
+    // up-front, which means only a single producer will be able to enqueue elements
+    // without an extra allocation -- blocks aren't shared between producers).
+    // This method is not thread safe -- it is up to the user to ensure that the
+    // queue is fully constructed before it starts being used by other threads (this
+    // includes making the memory effects of construction visible, possibly with a
+    // memory barrier).
+    explicit ConcurrentQueue(size_t capacity = 32 * BLOCK_SIZE)
+        : producerListTail(nullptr),
+        producerCount(0),
+        initialBlockPoolIndex(0),
+        nextExplicitConsumerId(0),
+        globalExplicitConsumerOffset(0)
+    {
+        implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
+        populate_initial_implicit_producer_hash();
+        populate_initial_block_list(capacity / BLOCK_SIZE + ((capacity & (BLOCK_SIZE - 1)) == 0 ? 0 : 1));
+        
 #ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		// Track all the producers using a fully-resolved typed list for
-		// each kind; this makes it possible to debug them starting from
-		// the root queue object (otherwise wacky casts are needed that
-		// don't compile in the debugger's expression evaluator).
-		explicitProducers.store(nullptr, std::memory_order_relaxed);
-		implicitProducers.store(nullptr, std::memory_order_relaxed);
-#endif
-	}
-	
-	// Computes the correct amount of pre-allocated blocks for you based
-	// on the minimum number of elements you want available at any given
-	// time, and the maximum concurrent number of each type of producer.
-	ConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers)
-		: producerListTail(nullptr),
-		producerCount(0),
-		initialBlockPoolIndex(0),
-		nextExplicitConsumerId(0),
-		globalExplicitConsumerOffset(0)
-	{
-		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-		populate_initial_implicit_producer_hash();
-		size_t blocks = (((minCapacity + BLOCK_SIZE - 1) / BLOCK_SIZE) - 1) * (maxExplicitProducers + 1) + 2 * (maxExplicitProducers + maxImplicitProducers);
-		populate_initial_block_list(blocks);
-		
+        // Track all the producers using a fully-resolved typed list for
+        // each kind; this makes it possible to debug them starting from
+        // the root queue object (otherwise wacky casts are needed that
+        // don't compile in the debugger's expression evaluator).
+        explicitProducers.store(nullptr, std::memory_order_relaxed);
+        implicitProducers.store(nullptr, std::memory_order_relaxed);
+#endif
+    }
+    
+    // Computes the correct amount of pre-allocated blocks for you based
+    // on the minimum number of elements you want available at any given
+    // time, and the maximum concurrent number of each type of producer.
+    ConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers)
+        : producerListTail(nullptr),
+        producerCount(0),
+        initialBlockPoolIndex(0),
+        nextExplicitConsumerId(0),
+        globalExplicitConsumerOffset(0)
+    {
+        implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
+        populate_initial_implicit_producer_hash();
+        size_t blocks = (((minCapacity + BLOCK_SIZE - 1) / BLOCK_SIZE) - 1) * (maxExplicitProducers + 1) + 2 * (maxExplicitProducers + maxImplicitProducers);
+        populate_initial_block_list(blocks);
+        
 #ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		explicitProducers.store(nullptr, std::memory_order_relaxed);
-		implicitProducers.store(nullptr, std::memory_order_relaxed);
-#endif
-	}
-	
-	// Note: The queue should not be accessed concurrently while it's
-	// being deleted. It's up to the user to synchronize this.
-	// This method is not thread safe.
-	~ConcurrentQueue()
-	{
-		// Destroy producers
-		auto ptr = producerListTail.load(std::memory_order_relaxed);
-		while (ptr != nullptr) {
-			auto next = ptr->next_prod();
-			if (ptr->token != nullptr) {
-				ptr->token->producer = nullptr;
-			}
-			destroy(ptr);
-			ptr = next;
-		}
-		
-		// Destroy implicit producer hash tables
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE != 0) {
-			auto hash = implicitProducerHash.load(std::memory_order_relaxed);
-			while (hash != nullptr) {
-				auto prev = hash->prev;
-				if (prev != nullptr) {		// The last hash is part of this object and was not allocated dynamically
-					for (size_t i = 0; i != hash->capacity; ++i) {
-						hash->entries[i].~ImplicitProducerKVP();
-					}
-					hash->~ImplicitProducerHash();
-					(Traits::free)(hash);
-				}
-				hash = prev;
-			}
-		}
-		
-		// Destroy global free list
-		auto block = freeList.head_unsafe();
-		while (block != nullptr) {
-			auto next = block->freeListNext.load(std::memory_order_relaxed);
-			if (block->dynamicallyAllocated) {
-				destroy(block);
-			}
-			block = next;
-		}
-		
-		// Destroy initial free list
-		destroy_array(initialBlockPool, initialBlockPoolSize);
-	}
-
-	// Disable copying and copy assignment
-	ConcurrentQueue(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
-	ConcurrentQueue& operator=(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
-	
-	// Moving is supported, but note that it is *not* a thread-safe operation.
-	// Nobody can use the queue while it's being moved, and the memory effects
-	// of that move must be propagated to other threads before they can use it.
-	// Note: When a queue is moved, its tokens are still valid but can only be
-	// used with the destination queue (i.e. semantically they are moved along
-	// with the queue itself).
-	ConcurrentQueue(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
-		: producerListTail(other.producerListTail.load(std::memory_order_relaxed)),
-		producerCount(other.producerCount.load(std::memory_order_relaxed)),
-		initialBlockPoolIndex(other.initialBlockPoolIndex.load(std::memory_order_relaxed)),
-		initialBlockPool(other.initialBlockPool),
-		initialBlockPoolSize(other.initialBlockPoolSize),
-		freeList(std::move(other.freeList)),
-		nextExplicitConsumerId(other.nextExplicitConsumerId.load(std::memory_order_relaxed)),
-		globalExplicitConsumerOffset(other.globalExplicitConsumerOffset.load(std::memory_order_relaxed))
-	{
-		// Move the other one into this, and leave the other one as an empty queue
-		implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-		populate_initial_implicit_producer_hash();
-		swap_implicit_producer_hashes(other);
-		
-		other.producerListTail.store(nullptr, std::memory_order_relaxed);
-		other.producerCount.store(0, std::memory_order_relaxed);
-		other.nextExplicitConsumerId.store(0, std::memory_order_relaxed);
-		other.globalExplicitConsumerOffset.store(0, std::memory_order_relaxed);
-		
+        explicitProducers.store(nullptr, std::memory_order_relaxed);
+        implicitProducers.store(nullptr, std::memory_order_relaxed);
+#endif
+    }
+    
+    // Note: The queue should not be accessed concurrently while it's
+    // being deleted. It's up to the user to synchronize this.
+    // This method is not thread safe.
+    ~ConcurrentQueue()
+    {
+        // Destroy producers
+        auto ptr = producerListTail.load(std::memory_order_relaxed);
+        while (ptr != nullptr) {
+            auto next = ptr->next_prod();
+            if (ptr->token != nullptr) {
+                ptr->token->producer = nullptr;
+            }
+            destroy(ptr);
+            ptr = next;
+        }
+        
+        // Destroy implicit producer hash tables
+        MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE != 0) {
+            auto hash = implicitProducerHash.load(std::memory_order_relaxed);
+            while (hash != nullptr) {
+                auto prev = hash->prev;
+                if (prev != nullptr) {		// The last hash is part of this object and was not allocated dynamically
+                    for (size_t i = 0; i != hash->capacity; ++i) {
+                        hash->entries[i].~ImplicitProducerKVP();
+                    }
+                    hash->~ImplicitProducerHash();
+                    (Traits::free)(hash);
+                }
+                hash = prev;
+            }
+        }
+        
+        // Destroy global free list
+        auto block = freeList.head_unsafe();
+        while (block != nullptr) {
+            auto next = block->freeListNext.load(std::memory_order_relaxed);
+            if (block->dynamicallyAllocated) {
+                destroy(block);
+            }
+            block = next;
+        }
+        
+        // Destroy initial free list
+        destroy_array(initialBlockPool, initialBlockPoolSize);
+    }
+
+    // Disable copying and copy assignment
+    ConcurrentQueue(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
+    ConcurrentQueue& operator=(ConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
+    
+    // Moving is supported, but note that it is *not* a thread-safe operation.
+    // Nobody can use the queue while it's being moved, and the memory effects
+    // of that move must be propagated to other threads before they can use it.
+    // Note: When a queue is moved, its tokens are still valid but can only be
+    // used with the destination queue (i.e. semantically they are moved along
+    // with the queue itself).
+    ConcurrentQueue(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
+        : producerListTail(other.producerListTail.load(std::memory_order_relaxed)),
+        producerCount(other.producerCount.load(std::memory_order_relaxed)),
+        initialBlockPoolIndex(other.initialBlockPoolIndex.load(std::memory_order_relaxed)),
+        initialBlockPool(other.initialBlockPool),
+        initialBlockPoolSize(other.initialBlockPoolSize),
+        freeList(std::move(other.freeList)),
+        nextExplicitConsumerId(other.nextExplicitConsumerId.load(std::memory_order_relaxed)),
+        globalExplicitConsumerOffset(other.globalExplicitConsumerOffset.load(std::memory_order_relaxed))
+    {
+        // Move the other one into this, and leave the other one as an empty queue
+        implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
+        populate_initial_implicit_producer_hash();
+        swap_implicit_producer_hashes(other);
+        
+        other.producerListTail.store(nullptr, std::memory_order_relaxed);
+        other.producerCount.store(0, std::memory_order_relaxed);
+        other.nextExplicitConsumerId.store(0, std::memory_order_relaxed);
+        other.globalExplicitConsumerOffset.store(0, std::memory_order_relaxed);
+        
 #ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		explicitProducers.store(other.explicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
-		other.explicitProducers.store(nullptr, std::memory_order_relaxed);
-		implicitProducers.store(other.implicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
-		other.implicitProducers.store(nullptr, std::memory_order_relaxed);
-#endif
-		
-		other.initialBlockPoolIndex.store(0, std::memory_order_relaxed);
-		other.initialBlockPoolSize = 0;
-		other.initialBlockPool = nullptr;
-		
-		reown_producers();
-	}
-	
-	inline ConcurrentQueue& operator=(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
-	{
-		return swap_internal(other);
-	}
-	
-	// Swaps this queue's state with the other's. Not thread-safe.
-	// Swapping two queues does not invalidate their tokens, however
-	// the tokens that were created for one queue must be used with
-	// only the swapped queue (i.e. the tokens are tied to the
-	// queue's movable state, not the object itself).
-	inline void swap(ConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
-	{
-		swap_internal(other);
-	}
-	
+        explicitProducers.store(other.explicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
+        other.explicitProducers.store(nullptr, std::memory_order_relaxed);
+        implicitProducers.store(other.implicitProducers.load(std::memory_order_relaxed), std::memory_order_relaxed);
+        other.implicitProducers.store(nullptr, std::memory_order_relaxed);
+#endif
+        
+        other.initialBlockPoolIndex.store(0, std::memory_order_relaxed);
+        other.initialBlockPoolSize = 0;
+        other.initialBlockPool = nullptr;
+        
+        reown_producers();
+    }
+    
+    inline ConcurrentQueue& operator=(ConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
+    {
+        return swap_internal(other);
+    }
+    
+    // Swaps this queue's state with the other's. Not thread-safe.
+    // Swapping two queues does not invalidate their tokens, however
+    // the tokens that were created for one queue must be used with
+    // only the swapped queue (i.e. the tokens are tied to the
+    // queue's movable state, not the object itself).
+    inline void swap(ConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
+    {
+        swap_internal(other);
+    }
+    
 private:
-	ConcurrentQueue& swap_internal(ConcurrentQueue& other)
-	{
-		if (this == &other) {
-			return *this;
-		}
-		
-		details::swap_relaxed(producerListTail, other.producerListTail);
-		details::swap_relaxed(producerCount, other.producerCount);
-		details::swap_relaxed(initialBlockPoolIndex, other.initialBlockPoolIndex);
-		std::swap(initialBlockPool, other.initialBlockPool);
-		std::swap(initialBlockPoolSize, other.initialBlockPoolSize);
-		freeList.swap(other.freeList);
-		details::swap_relaxed(nextExplicitConsumerId, other.nextExplicitConsumerId);
-		details::swap_relaxed(globalExplicitConsumerOffset, other.globalExplicitConsumerOffset);
-		
-		swap_implicit_producer_hashes(other);
-		
-		reown_producers();
-		other.reown_producers();
-		
+    ConcurrentQueue& swap_internal(ConcurrentQueue& other)
+    {
+        if (this == &other) {
+            return *this;
+        }
+        
+        details::swap_relaxed(producerListTail, other.producerListTail);
+        details::swap_relaxed(producerCount, other.producerCount);
+        details::swap_relaxed(initialBlockPoolIndex, other.initialBlockPoolIndex);
+        std::swap(initialBlockPool, other.initialBlockPool);
+        std::swap(initialBlockPoolSize, other.initialBlockPoolSize);
+        freeList.swap(other.freeList);
+        details::swap_relaxed(nextExplicitConsumerId, other.nextExplicitConsumerId);
+        details::swap_relaxed(globalExplicitConsumerOffset, other.globalExplicitConsumerOffset);
+        
+        swap_implicit_producer_hashes(other);
+        
+        reown_producers();
+        other.reown_producers();
+        
 #ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		details::swap_relaxed(explicitProducers, other.explicitProducers);
-		details::swap_relaxed(implicitProducers, other.implicitProducers);
+        details::swap_relaxed(explicitProducers, other.explicitProducers);
+        details::swap_relaxed(implicitProducers, other.implicitProducers);
 #endif
-		
-		return *this;
-	}
-	
+        
+        return *this;
+    }
+    
 public:
-	// Enqueues a single item (by copying it).
-	// Allocates memory if required. Only fails if memory allocation fails (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
-	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(T const& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CanAlloc>(item);
-	}
-	
-	// Enqueues a single item (by moving it, if possible).
-	// Allocates memory if required. Only fails if memory allocation fails (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
-	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(T&& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CanAlloc>(std::move(item));
-	}
-	
-	// Enqueues a single item (by copying it) using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(producer_token_t const& token, T const& item)
-	{
-		return inner_enqueue<CanAlloc>(token, item);
-	}
-	
-	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Thread-safe.
-	inline bool enqueue(producer_token_t const& token, T&& item)
-	{
-		return inner_enqueue<CanAlloc>(token, std::move(item));
-	}
-	
-	// Enqueues several items.
-	// Allocates memory if required. Only fails if memory allocation fails (or
-	// implicit production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
-	// is 0, or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Note: Use std::make_move_iterator if the elements should be moved instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool enqueue_bulk(It itemFirst, size_t count)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue_bulk<CanAlloc>(itemFirst, count);
-	}
-	
-	// Enqueues several items using an explicit producer token.
-	// Allocates memory if required. Only fails if memory allocation fails
-	// (or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		return inner_enqueue_bulk<CanAlloc>(token, itemFirst, count);
-	}
-	
-	// Enqueues a single item (by copying it).
-	// Does not allocate memory. Fails if not enough room to enqueue (or implicit
-	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
-	// is 0).
-	// Thread-safe.
-	inline bool try_enqueue(T const& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CannotAlloc>(item);
-	}
-	
-	// Enqueues a single item (by moving it, if possible).
-	// Does not allocate memory (except for one-time implicit producer).
-	// Fails if not enough room to enqueue (or implicit production is
-	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
-	// Thread-safe.
-	inline bool try_enqueue(T&& item)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue<CannotAlloc>(std::move(item));
-	}
-	
-	// Enqueues a single item (by copying it) using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Thread-safe.
-	inline bool try_enqueue(producer_token_t const& token, T const& item)
-	{
-		return inner_enqueue<CannotAlloc>(token, item);
-	}
-	
-	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Thread-safe.
-	inline bool try_enqueue(producer_token_t const& token, T&& item)
-	{
-		return inner_enqueue<CannotAlloc>(token, std::move(item));
-	}
-	
-	// Enqueues several items.
-	// Does not allocate memory (except for one-time implicit producer).
-	// Fails if not enough room to enqueue (or implicit production is
-	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool try_enqueue_bulk(It itemFirst, size_t count)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
-		else return inner_enqueue_bulk<CannotAlloc>(itemFirst, count);
-	}
-	
-	// Enqueues several items using an explicit producer token.
-	// Does not allocate memory. Fails if not enough room to enqueue.
-	// Note: Use std::make_move_iterator if the elements should be moved
-	// instead of copied.
-	// Thread-safe.
-	template<typename It>
-	bool try_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		return inner_enqueue_bulk<CannotAlloc>(token, itemFirst, count);
-	}
-	
-	
-	
-	// Attempts to dequeue from the queue.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	bool try_dequeue(U& item)
-	{
-		// Instead of simply trying each producer in turn (which could cause needless contention on the first
-		// producer), we score them heuristically.
-		size_t nonEmptyCount = 0;
-		ProducerBase* best = nullptr;
-		size_t bestSize = 0;
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); nonEmptyCount < 3 && ptr != nullptr; ptr = ptr->next_prod()) {
-			auto size = ptr->size_approx();
-			if (size > 0) {
-				if (size > bestSize) {
-					bestSize = size;
-					best = ptr;
-				}
-				++nonEmptyCount;
-			}
-		}
-		
-		// If there was at least one non-empty queue but it appears empty at the time
-		// we try to dequeue from it, we need to make sure every queue's been tried
-		if (nonEmptyCount > 0) {
-			if ((details::likely)(best->dequeue(item))) {
-				return true;
-			}
-			for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-				if (ptr != best && ptr->dequeue(item)) {
-					return true;
-				}
-			}
-		}
-		return false;
-	}
-	
-	// Attempts to dequeue from the queue.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// This differs from the try_dequeue(item) method in that this one does
-	// not attempt to reduce contention by interleaving the order that producer
-	// streams are dequeued from. So, using this method can reduce overall throughput
-	// under contention, but will give more predictable results in single-threaded
-	// consumer scenarios. This is mostly only useful for internal unit tests.
-	// Never allocates. Thread-safe.
-	template<typename U>
-	bool try_dequeue_non_interleaved(U& item)
-	{
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			if (ptr->dequeue(item)) {
-				return true;
-			}
-		}
-		return false;
-	}
-	
-	// Attempts to dequeue from the queue using an explicit consumer token.
-	// Returns false if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	bool try_dequeue(consumer_token_t& token, U& item)
-	{
-		// The idea is roughly as follows:
-		// Every 256 items from one producer, make everyone rotate (increase the global offset) -> this means the highest efficiency consumer dictates the rotation speed of everyone else, more or less
-		// If you see that the global offset has changed, you must reset your consumption counter and move to your designated place
-		// If there's no items where you're supposed to be, keep moving until you find a producer with some items
-		// If the global offset has not changed but you've run out of items to consume, move over from your current position until you find an producer with something in it
-		
-		if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
-			if (!update_current_producer_after_rotation(token)) {
-				return false;
-			}
-		}
-		
-		// If there was at least one non-empty queue but it appears empty at the time
-		// we try to dequeue from it, we need to make sure every queue's been tried
-		if (static_cast<ProducerBase*>(token.currentProducer)->dequeue(item)) {
-			if (++token.itemsConsumedFromCurrent == EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
-				globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
-			}
-			return true;
-		}
-		
-		auto tail = producerListTail.load(std::memory_order_acquire);
-		auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
-		if (ptr == nullptr) {
-			ptr = tail;
-		}
-		while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
-			if (ptr->dequeue(item)) {
-				token.currentProducer = ptr;
-				token.itemsConsumedFromCurrent = 1;
-				return true;
-			}
-			ptr = ptr->next_prod();
-			if (ptr == nullptr) {
-				ptr = tail;
-			}
-		}
-		return false;
-	}
-	
-	// Attempts to dequeue several elements from the queue.
-	// Returns the number of items actually dequeued.
-	// Returns 0 if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	size_t try_dequeue_bulk(It itemFirst, size_t max)
-	{
-		size_t count = 0;
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			count += ptr->dequeue_bulk(itemFirst, max - count);
-			if (count == max) {
-				break;
-			}
-		}
-		return count;
-	}
-	
-	// Attempts to dequeue several elements from the queue using an explicit consumer token.
-	// Returns the number of items actually dequeued.
-	// Returns 0 if all producer streams appeared empty at the time they
-	// were checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
-	{
-		if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
-			if (!update_current_producer_after_rotation(token)) {
-				return 0;
-			}
-		}
-		
-		size_t count = static_cast<ProducerBase*>(token.currentProducer)->dequeue_bulk(itemFirst, max);
-		if (count == max) {
-			if ((token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(max)) >= EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
-				globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
-			}
-			return max;
-		}
-		token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(count);
-		max -= count;
-		
-		auto tail = producerListTail.load(std::memory_order_acquire);
-		auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
-		if (ptr == nullptr) {
-			ptr = tail;
-		}
-		while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
-			auto dequeued = ptr->dequeue_bulk(itemFirst, max);
-			count += dequeued;
-			if (dequeued != 0) {
-				token.currentProducer = ptr;
-				token.itemsConsumedFromCurrent = static_cast<std::uint32_t>(dequeued);
-			}
-			if (dequeued == max) {
-				break;
-			}
-			max -= dequeued;
-			ptr = ptr->next_prod();
-			if (ptr == nullptr) {
-				ptr = tail;
-			}
-		}
-		return count;
-	}
-	
-	
-	
-	// Attempts to dequeue from a specific producer's inner queue.
-	// If you happen to know which producer you want to dequeue from, this
-	// is significantly faster than using the general-case try_dequeue methods.
-	// Returns false if the producer's queue appeared empty at the time it
-	// was checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename U>
-	inline bool try_dequeue_from_producer(producer_token_t const& producer, U& item)
-	{
-		return static_cast<ExplicitProducer*>(producer.producer)->dequeue(item);
-	}
-	
-	// Attempts to dequeue several elements from a specific producer's inner queue.
-	// Returns the number of items actually dequeued.
-	// If you happen to know which producer you want to dequeue from, this
-	// is significantly faster than using the general-case try_dequeue methods.
-	// Returns 0 if the producer's queue appeared empty at the time it
-	// was checked (so, the queue is likely but not guaranteed to be empty).
-	// Never allocates. Thread-safe.
-	template<typename It>
-	inline size_t try_dequeue_bulk_from_producer(producer_token_t const& producer, It itemFirst, size_t max)
-	{
-		return static_cast<ExplicitProducer*>(producer.producer)->dequeue_bulk(itemFirst, max);
-	}
-	
-	
-	// Returns an estimate of the total number of elements currently in the queue. This
-	// estimate is only accurate if the queue has completely stabilized before it is called
-	// (i.e. all enqueue and dequeue operations have completed and their memory effects are
-	// visible on the calling thread, and no further operations start while this method is
-	// being called).
-	// Thread-safe.
-	size_t size_approx() const
-	{
-		size_t size = 0;
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			size += ptr->size_approx();
-		}
-		return size;
-	}
-	
-	
-	// Returns true if the underlying atomic variables used by
-	// the queue are lock-free (they should be on most platforms).
-	// Thread-safe.
-	static constexpr bool is_lock_free()
-	{
-		return
-			details::static_is_lock_free<bool>::value == 2 &&
-			details::static_is_lock_free<size_t>::value == 2 &&
-			details::static_is_lock_free<std::uint32_t>::value == 2 &&
-			details::static_is_lock_free<index_t>::value == 2 &&
-			details::static_is_lock_free<void*>::value == 2 &&
-			details::static_is_lock_free<typename details::thread_id_converter<details::thread_id_t>::thread_id_numeric_size_t>::value == 2;
-	}
+    // Enqueues a single item (by copying it).
+    // Allocates memory if required. Only fails if memory allocation fails (or implicit
+    // production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
+    // or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+    // Thread-safe.
+    inline bool enqueue(T const& item)
+    {
+        MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+        else return inner_enqueue<CanAlloc>(item);
+    }
+    
+    // Enqueues a single item (by moving it, if possible).
+    // Allocates memory if required. Only fails if memory allocation fails (or implicit
+    // production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
+    // or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+    // Thread-safe.
+    inline bool enqueue(T&& item)
+    {
+        MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+        else return inner_enqueue<CanAlloc>(std::move(item));
+    }
+    
+    // Enqueues a single item (by copying it) using an explicit producer token.
+    // Allocates memory if required. Only fails if memory allocation fails (or
+    // Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+    // Thread-safe.
+    inline bool enqueue(producer_token_t const& token, T const& item)
+    {
+        return inner_enqueue<CanAlloc>(token, item);
+    }
+    
+    // Enqueues a single item (by moving it, if possible) using an explicit producer token.
+    // Allocates memory if required. Only fails if memory allocation fails (or
+    // Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+    // Thread-safe.
+    inline bool enqueue(producer_token_t const& token, T&& item)
+    {
+        return inner_enqueue<CanAlloc>(token, std::move(item));
+    }
+    
+    // Enqueues several items.
+    // Allocates memory if required. Only fails if memory allocation fails (or
+    // implicit production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
+    // is 0, or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+    // Note: Use std::make_move_iterator if the elements should be moved instead of copied.
+    // Thread-safe.
+    template<typename It>
+    bool enqueue_bulk(It itemFirst, size_t count)
+    {
+        MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+        else return inner_enqueue_bulk<CanAlloc>(itemFirst, count);
+    }
+    
+    // Enqueues several items using an explicit producer token.
+    // Allocates memory if required. Only fails if memory allocation fails
+    // (or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+    // Note: Use std::make_move_iterator if the elements should be moved
+    // instead of copied.
+    // Thread-safe.
+    template<typename It>
+    bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
+    {
+        return inner_enqueue_bulk<CanAlloc>(token, itemFirst, count);
+    }
+    
+    // Enqueues a single item (by copying it).
+    // Does not allocate memory. Fails if not enough room to enqueue (or implicit
+    // production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
+    // is 0).
+    // Thread-safe.
+    inline bool try_enqueue(T const& item)
+    {
+        MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+        else return inner_enqueue<CannotAlloc>(item);
+    }
+    
+    // Enqueues a single item (by moving it, if possible).
+    // Does not allocate memory (except for one-time implicit producer).
+    // Fails if not enough room to enqueue (or implicit production is
+    // disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
+    // Thread-safe.
+    inline bool try_enqueue(T&& item)
+    {
+        MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+        else return inner_enqueue<CannotAlloc>(std::move(item));
+    }
+    
+    // Enqueues a single item (by copying it) using an explicit producer token.
+    // Does not allocate memory. Fails if not enough room to enqueue.
+    // Thread-safe.
+    inline bool try_enqueue(producer_token_t const& token, T const& item)
+    {
+        return inner_enqueue<CannotAlloc>(token, item);
+    }
+    
+    // Enqueues a single item (by moving it, if possible) using an explicit producer token.
+    // Does not allocate memory. Fails if not enough room to enqueue.
+    // Thread-safe.
+    inline bool try_enqueue(producer_token_t const& token, T&& item)
+    {
+        return inner_enqueue<CannotAlloc>(token, std::move(item));
+    }
+    
+    // Enqueues several items.
+    // Does not allocate memory (except for one-time implicit producer).
+    // Fails if not enough room to enqueue (or implicit production is
+    // disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
+    // Note: Use std::make_move_iterator if the elements should be moved
+    // instead of copied.
+    // Thread-safe.
+    template<typename It>
+    bool try_enqueue_bulk(It itemFirst, size_t count)
+    {
+        MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+        else return inner_enqueue_bulk<CannotAlloc>(itemFirst, count);
+    }
+    
+    // Enqueues several items using an explicit producer token.
+    // Does not allocate memory. Fails if not enough room to enqueue.
+    // Note: Use std::make_move_iterator if the elements should be moved
+    // instead of copied.
+    // Thread-safe.
+    template<typename It>
+    bool try_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
+    {
+        return inner_enqueue_bulk<CannotAlloc>(token, itemFirst, count);
+    }
+    
+    
+    
+    // Attempts to dequeue from the queue.
+    // Returns false if all producer streams appeared empty at the time they
+    // were checked (so, the queue is likely but not guaranteed to be empty).
+    // Never allocates. Thread-safe.
+    template<typename U>
+    bool try_dequeue(U& item)
+    {
+        // Instead of simply trying each producer in turn (which could cause needless contention on the first
+        // producer), we score them heuristically.
+        size_t nonEmptyCount = 0;
+        ProducerBase* best = nullptr;
+        size_t bestSize = 0;
+        for (auto ptr = producerListTail.load(std::memory_order_acquire); nonEmptyCount < 3 && ptr != nullptr; ptr = ptr->next_prod()) {
+            auto size = ptr->size_approx();
+            if (size > 0) {
+                if (size > bestSize) {
+                    bestSize = size;
+                    best = ptr;
+                }
+                ++nonEmptyCount;
+            }
+        }
+        
+        // If there was at least one non-empty queue but it appears empty at the time
+        // we try to dequeue from it, we need to make sure every queue's been tried
+        if (nonEmptyCount > 0) {
+            if ((details::likely)(best->dequeue(item))) {
+                return true;
+            }
+            for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+                if (ptr != best && ptr->dequeue(item)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    
+    // Attempts to dequeue from the queue.
+    // Returns false if all producer streams appeared empty at the time they
+    // were checked (so, the queue is likely but not guaranteed to be empty).
+    // This differs from the try_dequeue(item) method in that this one does
+    // not attempt to reduce contention by interleaving the order that producer
+    // streams are dequeued from. So, using this method can reduce overall throughput
+    // under contention, but will give more predictable results in single-threaded
+    // consumer scenarios. This is mostly only useful for internal unit tests.
+    // Never allocates. Thread-safe.
+    template<typename U>
+    bool try_dequeue_non_interleaved(U& item)
+    {
+        for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+            if (ptr->dequeue(item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    // Attempts to dequeue from the queue using an explicit consumer token.
+    // Returns false if all producer streams appeared empty at the time they
+    // were checked (so, the queue is likely but not guaranteed to be empty).
+    // Never allocates. Thread-safe.
+    template<typename U>
+    bool try_dequeue(consumer_token_t& token, U& item)
+    {
+        // The idea is roughly as follows:
+        // Every 256 items from one producer, make everyone rotate (increase the global offset) -> this means the highest efficiency consumer dictates the rotation speed of everyone else, more or less
+        // If you see that the global offset has changed, you must reset your consumption counter and move to your designated place
+        // If there's no items where you're supposed to be, keep moving until you find a producer with some items
+        // If the global offset has not changed but you've run out of items to consume, move over from your current position until you find an producer with something in it
+        
+        if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
+            if (!update_current_producer_after_rotation(token)) {
+                return false;
+            }
+        }
+        
+        // If there was at least one non-empty queue but it appears empty at the time
+        // we try to dequeue from it, we need to make sure every queue's been tried
+        if (static_cast<ProducerBase*>(token.currentProducer)->dequeue(item)) {
+            if (++token.itemsConsumedFromCurrent == EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
+                globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
+            }
+            return true;
+        }
+        
+        auto tail = producerListTail.load(std::memory_order_acquire);
+        auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
+        if (ptr == nullptr) {
+            ptr = tail;
+        }
+        while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
+            if (ptr->dequeue(item)) {
+                token.currentProducer = ptr;
+                token.itemsConsumedFromCurrent = 1;
+                return true;
+            }
+            ptr = ptr->next_prod();
+            if (ptr == nullptr) {
+                ptr = tail;
+            }
+        }
+        return false;
+    }
+    
+    // Attempts to dequeue several elements from the queue.
+    // Returns the number of items actually dequeued.
+    // Returns 0 if all producer streams appeared empty at the time they
+    // were checked (so, the queue is likely but not guaranteed to be empty).
+    // Never allocates. Thread-safe.
+    template<typename It>
+    size_t try_dequeue_bulk(It itemFirst, size_t max)
+    {
+        size_t count = 0;
+        for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+            count += ptr->dequeue_bulk(itemFirst, max - count);
+            if (count == max) {
+                break;
+            }
+        }
+        return count;
+    }
+    
+    // Attempts to dequeue several elements from the queue using an explicit consumer token.
+    // Returns the number of items actually dequeued.
+    // Returns 0 if all producer streams appeared empty at the time they
+    // were checked (so, the queue is likely but not guaranteed to be empty).
+    // Never allocates. Thread-safe.
+    template<typename It>
+    size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
+    {
+        if (token.desiredProducer == nullptr || token.lastKnownGlobalOffset != globalExplicitConsumerOffset.load(std::memory_order_relaxed)) {
+            if (!update_current_producer_after_rotation(token)) {
+                return 0;
+            }
+        }
+        
+        size_t count = static_cast<ProducerBase*>(token.currentProducer)->dequeue_bulk(itemFirst, max);
+        if (count == max) {
+            if ((token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(max)) >= EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE) {
+                globalExplicitConsumerOffset.fetch_add(1, std::memory_order_relaxed);
+            }
+            return max;
+        }
+        token.itemsConsumedFromCurrent += static_cast<std::uint32_t>(count);
+        max -= count;
+        
+        auto tail = producerListTail.load(std::memory_order_acquire);
+        auto ptr = static_cast<ProducerBase*>(token.currentProducer)->next_prod();
+        if (ptr == nullptr) {
+            ptr = tail;
+        }
+        while (ptr != static_cast<ProducerBase*>(token.currentProducer)) {
+            auto dequeued = ptr->dequeue_bulk(itemFirst, max);
+            count += dequeued;
+            if (dequeued != 0) {
+                token.currentProducer = ptr;
+                token.itemsConsumedFromCurrent = static_cast<std::uint32_t>(dequeued);
+            }
+            if (dequeued == max) {
+                break;
+            }
+            max -= dequeued;
+            ptr = ptr->next_prod();
+            if (ptr == nullptr) {
+                ptr = tail;
+            }
+        }
+        return count;
+    }
+    
+    
+    
+    // Attempts to dequeue from a specific producer's inner queue.
+    // If you happen to know which producer you want to dequeue from, this
+    // is significantly faster than using the general-case try_dequeue methods.
+    // Returns false if the producer's queue appeared empty at the time it
+    // was checked (so, the queue is likely but not guaranteed to be empty).
+    // Never allocates. Thread-safe.
+    template<typename U>
+    inline bool try_dequeue_from_producer(producer_token_t const& producer, U& item)
+    {
+        return static_cast<ExplicitProducer*>(producer.producer)->dequeue(item);
+    }
+    
+    // Attempts to dequeue several elements from a specific producer's inner queue.
+    // Returns the number of items actually dequeued.
+    // If you happen to know which producer you want to dequeue from, this
+    // is significantly faster than using the general-case try_dequeue methods.
+    // Returns 0 if the producer's queue appeared empty at the time it
+    // was checked (so, the queue is likely but not guaranteed to be empty).
+    // Never allocates. Thread-safe.
+    template<typename It>
+    inline size_t try_dequeue_bulk_from_producer(producer_token_t const& producer, It itemFirst, size_t max)
+    {
+        return static_cast<ExplicitProducer*>(producer.producer)->dequeue_bulk(itemFirst, max);
+    }
+    
+    
+    // Returns an estimate of the total number of elements currently in the queue. This
+    // estimate is only accurate if the queue has completely stabilized before it is called
+    // (i.e. all enqueue and dequeue operations have completed and their memory effects are
+    // visible on the calling thread, and no further operations start while this method is
+    // being called).
+    // Thread-safe.
+    size_t size_approx() const
+    {
+        size_t size = 0;
+        for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+            size += ptr->size_approx();
+        }
+        return size;
+    }
+    
+    
+    // Returns true if the underlying atomic variables used by
+    // the queue are lock-free (they should be on most platforms).
+    // Thread-safe.
+    static constexpr bool is_lock_free()
+    {
+        return
+            details::static_is_lock_free<bool>::value == 2 &&
+            details::static_is_lock_free<size_t>::value == 2 &&
+            details::static_is_lock_free<std::uint32_t>::value == 2 &&
+            details::static_is_lock_free<index_t>::value == 2 &&
+            details::static_is_lock_free<void*>::value == 2 &&
+            details::static_is_lock_free<typename details::thread_id_converter<details::thread_id_t>::thread_id_numeric_size_t>::value == 2;
+    }
 
 
 private:
-	friend struct ProducerToken;
-	friend struct ConsumerToken;
-	struct ExplicitProducer;
-	friend struct ExplicitProducer;
-	struct ImplicitProducer;
-	friend struct ImplicitProducer;
-	friend class ConcurrentQueueTests;
-		
-	enum AllocationMode { CanAlloc, CannotAlloc };
-	
-	
-	///////////////////////////////
-	// Queue methods
-	///////////////////////////////
-	
-	template<AllocationMode canAlloc, typename U>
-	inline bool inner_enqueue(producer_token_t const& token, U&& element)
-	{
-		return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
-	}
-	
-	template<AllocationMode canAlloc, typename U>
-	inline bool inner_enqueue(U&& element)
-	{
-		auto producer = get_or_add_implicit_producer();
-		return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
-	}
-	
-	template<AllocationMode canAlloc, typename It>
-	inline bool inner_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
-	{
-		return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
-	}
-	
-	template<AllocationMode canAlloc, typename It>
-	inline bool inner_enqueue_bulk(It itemFirst, size_t count)
-	{
-		auto producer = get_or_add_implicit_producer();
-		return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
-	}
-	
-	inline bool update_current_producer_after_rotation(consumer_token_t& token)
-	{
-		// Ah, there's been a rotation, figure out where we should be!
-		auto tail = producerListTail.load(std::memory_order_acquire);
-		if (token.desiredProducer == nullptr && tail == nullptr) {
-			return false;
-		}
-		auto prodCount = producerCount.load(std::memory_order_relaxed);
-		auto globalOffset = globalExplicitConsumerOffset.load(std::memory_order_relaxed);
-		if ((details::unlikely)(token.desiredProducer == nullptr)) {
-			// Aha, first time we're dequeueing anything.
-			// Figure out our local position
-			// Note: offset is from start, not end, but we're traversing from end -- subtract from count first
-			std::uint32_t offset = prodCount - 1 - (token.initialOffset % prodCount);
-			token.desiredProducer = tail;
-			for (std::uint32_t i = 0; i != offset; ++i) {
-				token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
-				if (token.desiredProducer == nullptr) {
-					token.desiredProducer = tail;
-				}
-			}
-		}
-		
-		std::uint32_t delta = globalOffset - token.lastKnownGlobalOffset;
-		if (delta >= prodCount) {
-			delta = delta % prodCount;
-		}
-		for (std::uint32_t i = 0; i != delta; ++i) {
-			token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
-			if (token.desiredProducer == nullptr) {
-				token.desiredProducer = tail;
-			}
-		}
-		
-		token.lastKnownGlobalOffset = globalOffset;
-		token.currentProducer = token.desiredProducer;
-		token.itemsConsumedFromCurrent = 0;
-		return true;
-	}
-	
-	
-	///////////////////////////
-	// Free list
-	///////////////////////////
-	
-	template <typename N>
-	struct FreeListNode
-	{
-		FreeListNode() : freeListRefs(0), freeListNext(nullptr) { }
-		
-		std::atomic<std::uint32_t> freeListRefs;
-		std::atomic<N*> freeListNext;
-	};
-	
-	// A simple CAS-based lock-free free list. Not the fastest thing in the world under heavy contention, but
-	// simple and correct (assuming nodes are never freed until after the free list is destroyed), and fairly
-	// speedy under low contention.
-	template<typename N>		// N must inherit FreeListNode or have the same fields (and initialization of them)
-	struct FreeList
-	{
-		FreeList() : freeListHead(nullptr) { }
-		FreeList(FreeList&& other) : freeListHead(other.freeListHead.load(std::memory_order_relaxed)) { other.freeListHead.store(nullptr, std::memory_order_relaxed); }
-		void swap(FreeList& other) { details::swap_relaxed(freeListHead, other.freeListHead); }
-		
-		FreeList(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
-		FreeList& operator=(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
-		
-		inline void add(N* node)
-		{
+    friend struct ProducerToken;
+    friend struct ConsumerToken;
+    struct ExplicitProducer;
+    friend struct ExplicitProducer;
+    struct ImplicitProducer;
+    friend struct ImplicitProducer;
+    friend class ConcurrentQueueTests;
+        
+    enum AllocationMode { CanAlloc, CannotAlloc };
+    
+    
+    ///////////////////////////////
+    // Queue methods
+    ///////////////////////////////
+    
+    template<AllocationMode canAlloc, typename U>
+    inline bool inner_enqueue(producer_token_t const& token, U&& element)
+    {
+        return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
+    }
+    
+    template<AllocationMode canAlloc, typename U>
+    inline bool inner_enqueue(U&& element)
+    {
+        auto producer = get_or_add_implicit_producer();
+        return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
+    }
+    
+    template<AllocationMode canAlloc, typename It>
+    inline bool inner_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
+    {
+        return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
+    }
+    
+    template<AllocationMode canAlloc, typename It>
+    inline bool inner_enqueue_bulk(It itemFirst, size_t count)
+    {
+        auto producer = get_or_add_implicit_producer();
+        return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue_bulk<canAlloc>(itemFirst, count);
+    }
+    
+    inline bool update_current_producer_after_rotation(consumer_token_t& token)
+    {
+        // Ah, there's been a rotation, figure out where we should be!
+        auto tail = producerListTail.load(std::memory_order_acquire);
+        if (token.desiredProducer == nullptr && tail == nullptr) {
+            return false;
+        }
+        auto prodCount = producerCount.load(std::memory_order_relaxed);
+        auto globalOffset = globalExplicitConsumerOffset.load(std::memory_order_relaxed);
+        if ((details::unlikely)(token.desiredProducer == nullptr)) {
+            // Aha, first time we're dequeueing anything.
+            // Figure out our local position
+            // Note: offset is from start, not end, but we're traversing from end -- subtract from count first
+            std::uint32_t offset = prodCount - 1 - (token.initialOffset % prodCount);
+            token.desiredProducer = tail;
+            for (std::uint32_t i = 0; i != offset; ++i) {
+                token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
+                if (token.desiredProducer == nullptr) {
+                    token.desiredProducer = tail;
+                }
+            }
+        }
+        
+        std::uint32_t delta = globalOffset - token.lastKnownGlobalOffset;
+        if (delta >= prodCount) {
+            delta = delta % prodCount;
+        }
+        for (std::uint32_t i = 0; i != delta; ++i) {
+            token.desiredProducer = static_cast<ProducerBase*>(token.desiredProducer)->next_prod();
+            if (token.desiredProducer == nullptr) {
+                token.desiredProducer = tail;
+            }
+        }
+        
+        token.lastKnownGlobalOffset = globalOffset;
+        token.currentProducer = token.desiredProducer;
+        token.itemsConsumedFromCurrent = 0;
+        return true;
+    }
+    
+    
+    ///////////////////////////
+    // Free list
+    ///////////////////////////
+    
+    template <typename N>
+    struct FreeListNode
+    {
+        FreeListNode() : freeListRefs(0), freeListNext(nullptr) { }
+        
+        std::atomic<std::uint32_t> freeListRefs;
+        std::atomic<N*> freeListNext;
+    };
+    
+    // A simple CAS-based lock-free free list. Not the fastest thing in the world under heavy contention, but
+    // simple and correct (assuming nodes are never freed until after the free list is destroyed), and fairly
+    // speedy under low contention.
+    template<typename N>		// N must inherit FreeListNode or have the same fields (and initialization of them)
+    struct FreeList
+    {
+        FreeList() : freeListHead(nullptr) { }
+        FreeList(FreeList&& other) : freeListHead(other.freeListHead.load(std::memory_order_relaxed)) { other.freeListHead.store(nullptr, std::memory_order_relaxed); }
+        void swap(FreeList& other) { details::swap_relaxed(freeListHead, other.freeListHead); }
+        
+        FreeList(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
+        FreeList& operator=(FreeList const&) MOODYCAMEL_DELETE_FUNCTION;
+        
+        inline void add(N* node)
+        {
 #ifdef MCDBGQ_NOLOCKFREE_FREELIST
-			debug::DebugLock lock(mutex);
+            debug::DebugLock lock(mutex);
 #endif		
-			// We know that the should-be-on-freelist bit is 0 at this point, so it's safe to
-			// set it using a fetch_add
-			if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST, std::memory_order_acq_rel) == 0) {
-				// Oh look! We were the last ones referencing this node, and we know
-				// we want to add it to the free list, so let's do it!
-		 		add_knowing_refcount_is_zero(node);
-			}
-		}
-		
-		inline N* try_get()
-		{
+            // We know that the should-be-on-freelist bit is 0 at this point, so it's safe to
+            // set it using a fetch_add
+            if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST, std::memory_order_acq_rel) == 0) {
+                // Oh look! We were the last ones referencing this node, and we know
+                // we want to add it to the free list, so let's do it!
+                add_knowing_refcount_is_zero(node);
+            }
+        }
+        
+        inline N* try_get()
+        {
 #ifdef MCDBGQ_NOLOCKFREE_FREELIST
-			debug::DebugLock lock(mutex);
+            debug::DebugLock lock(mutex);
 #endif		
-			auto head = freeListHead.load(std::memory_order_acquire);
-			while (head != nullptr) {
-				auto prevHead = head;
-				auto refs = head->freeListRefs.load(std::memory_order_relaxed);
-				if ((refs & REFS_MASK) == 0 || !head->freeListRefs.compare_exchange_strong(refs, refs + 1, std::memory_order_acquire, std::memory_order_relaxed)) {
-					head = freeListHead.load(std::memory_order_acquire);
-					continue;
-				}
-				
-				// Good, reference count has been incremented (it wasn't at zero), which means we can read the
-				// next and not worry about it changing between now and the time we do the CAS
-				auto next = head->freeListNext.load(std::memory_order_relaxed);
-				if (freeListHead.compare_exchange_strong(head, next, std::memory_order_acquire, std::memory_order_relaxed)) {
-					// Yay, got the node. This means it was on the list, which means shouldBeOnFreeList must be false no
-					// matter the refcount (because nobody else knows it's been taken off yet, it can't have been put back on).
-					assert((head->freeListRefs.load(std::memory_order_relaxed) & SHOULD_BE_ON_FREELIST) == 0);
-					
-					// Decrease refcount twice, once for our ref, and once for the list's ref
-					head->freeListRefs.fetch_sub(2, std::memory_order_release);
-					return head;
-				}
-				
-				// OK, the head must have changed on us, but we still need to decrease the refcount we increased.
-				// Note that we don't need to release any memory effects, but we do need to ensure that the reference
-				// count decrement happens-after the CAS on the head.
-				refs = prevHead->freeListRefs.fetch_sub(1, std::memory_order_acq_rel);
-				if (refs == SHOULD_BE_ON_FREELIST + 1) {
-					add_knowing_refcount_is_zero(prevHead);
-				}
-			}
-			
-			return nullptr;
-		}
-		
-		// Useful for traversing the list when there's no contention (e.g. to destroy remaining nodes)
-		N* head_unsafe() const { return freeListHead.load(std::memory_order_relaxed); }
-		
-	private:
-		inline void add_knowing_refcount_is_zero(N* node)
-		{
-			// Since the refcount is zero, and nobody can increase it once it's zero (except us, and we run
-			// only one copy of this method per node at a time, i.e. the single thread case), then we know
-			// we can safely change the next pointer of the node; however, once the refcount is back above
-			// zero, then other threads could increase it (happens under heavy contention, when the refcount
-			// goes to zero in between a load and a refcount increment of a node in try_get, then back up to
-			// something non-zero, then the refcount increment is done by the other thread) -- so, if the CAS
-			// to add the node to the actual list fails, decrease the refcount and leave the add operation to
-			// the next thread who puts the refcount back at zero (which could be us, hence the loop).
-			auto head = freeListHead.load(std::memory_order_relaxed);
-			while (true) {
-				node->freeListNext.store(head, std::memory_order_relaxed);
-				node->freeListRefs.store(1, std::memory_order_release);
-				if (!freeListHead.compare_exchange_strong(head, node, std::memory_order_release, std::memory_order_relaxed)) {
-					// Hmm, the add failed, but we can only try again when the refcount goes back to zero
-					if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST - 1, std::memory_order_release) == 1) {
-						continue;
-					}
-				}
-				return;
-			}
-		}
-		
-	private:
-		// Implemented like a stack, but where node order doesn't matter (nodes are inserted out of order under contention)
-		std::atomic<N*> freeListHead;
-	
-	static const std::uint32_t REFS_MASK = 0x7FFFFFFF;
-	static const std::uint32_t SHOULD_BE_ON_FREELIST = 0x80000000;
-		
+            auto head = freeListHead.load(std::memory_order_acquire);
+            while (head != nullptr) {
+                auto prevHead = head;
+                auto refs = head->freeListRefs.load(std::memory_order_relaxed);
+                if ((refs & REFS_MASK) == 0 || !head->freeListRefs.compare_exchange_strong(refs, refs + 1, std::memory_order_acquire, std::memory_order_relaxed)) {
+                    head = freeListHead.load(std::memory_order_acquire);
+                    continue;
+                }
+                
+                // Good, reference count has been incremented (it wasn't at zero), which means we can read the
+                // next and not worry about it changing between now and the time we do the CAS
+                auto next = head->freeListNext.load(std::memory_order_relaxed);
+                if (freeListHead.compare_exchange_strong(head, next, std::memory_order_acquire, std::memory_order_relaxed)) {
+                    // Yay, got the node. This means it was on the list, which means shouldBeOnFreeList must be false no
+                    // matter the refcount (because nobody else knows it's been taken off yet, it can't have been put back on).
+                    assert((head->freeListRefs.load(std::memory_order_relaxed) & SHOULD_BE_ON_FREELIST) == 0);
+                    
+                    // Decrease refcount twice, once for our ref, and once for the list's ref
+                    head->freeListRefs.fetch_sub(2, std::memory_order_release);
+                    return head;
+                }
+                
+                // OK, the head must have changed on us, but we still need to decrease the refcount we increased.
+                // Note that we don't need to release any memory effects, but we do need to ensure that the reference
+                // count decrement happens-after the CAS on the head.
+                refs = prevHead->freeListRefs.fetch_sub(1, std::memory_order_acq_rel);
+                if (refs == SHOULD_BE_ON_FREELIST + 1) {
+                    add_knowing_refcount_is_zero(prevHead);
+                }
+            }
+            
+            return nullptr;
+        }
+        
+        // Useful for traversing the list when there's no contention (e.g. to destroy remaining nodes)
+        N* head_unsafe() const { return freeListHead.load(std::memory_order_relaxed); }
+        
+    private:
+        inline void add_knowing_refcount_is_zero(N* node)
+        {
+            // Since the refcount is zero, and nobody can increase it once it's zero (except us, and we run
+            // only one copy of this method per node at a time, i.e. the single thread case), then we know
+            // we can safely change the next pointer of the node; however, once the refcount is back above
+            // zero, then other threads could increase it (happens under heavy contention, when the refcount
+            // goes to zero in between a load and a refcount increment of a node in try_get, then back up to
+            // something non-zero, then the refcount increment is done by the other thread) -- so, if the CAS
+            // to add the node to the actual list fails, decrease the refcount and leave the add operation to
+            // the next thread who puts the refcount back at zero (which could be us, hence the loop).
+            auto head = freeListHead.load(std::memory_order_relaxed);
+            while (true) {
+                node->freeListNext.store(head, std::memory_order_relaxed);
+                node->freeListRefs.store(1, std::memory_order_release);
+                if (!freeListHead.compare_exchange_strong(head, node, std::memory_order_release, std::memory_order_relaxed)) {
+                    // Hmm, the add failed, but we can only try again when the refcount goes back to zero
+                    if (node->freeListRefs.fetch_add(SHOULD_BE_ON_FREELIST - 1, std::memory_order_release) == 1) {
+                        continue;
+                    }
+                }
+                return;
+            }
+        }
+        
+    private:
+        // Implemented like a stack, but where node order doesn't matter (nodes are inserted out of order under contention)
+        std::atomic<N*> freeListHead;
+    
+    static const std::uint32_t REFS_MASK = 0x7FFFFFFF;
+    static const std::uint32_t SHOULD_BE_ON_FREELIST = 0x80000000;
+        
 #ifdef MCDBGQ_NOLOCKFREE_FREELIST
-		debug::DebugMutex mutex;
-#endif
-	};
-	
-	
-	///////////////////////////
-	// Block
-	///////////////////////////
-	
-	enum InnerQueueContext { implicit_context = 0, explicit_context = 1 };
-	
-	struct Block
-	{
-		Block()
-			: next(nullptr), elementsCompletelyDequeued(0), freeListRefs(0), freeListNext(nullptr), dynamicallyAllocated(true)
-		{
+        debug::DebugMutex mutex;
+#endif
+    };
+    
+    
+    ///////////////////////////
+    // Block
+    ///////////////////////////
+    
+    enum InnerQueueContext { implicit_context = 0, explicit_context = 1 };
+    
+    struct Block
+    {
+        Block()
+            : next(nullptr), elementsCompletelyDequeued(0), freeListRefs(0), freeListNext(nullptr), dynamicallyAllocated(true)
+        {
 #ifdef MCDBGQ_TRACKMEM
-			owner = nullptr;
-#endif
-		}
-		
-		template<InnerQueueContext context>
-		inline bool is_empty() const
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Check flags
-				for (size_t i = 0; i < BLOCK_SIZE; ++i) {
-					if (!emptyFlags[i].load(std::memory_order_relaxed)) {
-						return false;
-					}
-				}
-				
-				// Aha, empty; make sure we have all other memory effects that happened before the empty flags were set
-				std::atomic_thread_fence(std::memory_order_acquire);
-				return true;
-			}
-			else {
-				// Check counter
-				if (elementsCompletelyDequeued.load(std::memory_order_relaxed) == BLOCK_SIZE) {
-					std::atomic_thread_fence(std::memory_order_acquire);
-					return true;
-				}
-				assert(elementsCompletelyDequeued.load(std::memory_order_relaxed) <= BLOCK_SIZE);
-				return false;
-			}
-		}
-		
-		// Returns true if the block is now empty (does not apply in explicit context)
-		template<InnerQueueContext context>
-		inline bool set_empty(MOODYCAMEL_MAYBE_UNUSED index_t i)
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Set flag
-				assert(!emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].load(std::memory_order_relaxed));
-				emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].store(true, std::memory_order_release);
-				return false;
-			}
-			else {
-				// Increment counter
-				auto prevVal = elementsCompletelyDequeued.fetch_add(1, std::memory_order_release);
-				assert(prevVal < BLOCK_SIZE);
-				return prevVal == BLOCK_SIZE - 1;
-			}
-		}
-		
-		// Sets multiple contiguous item statuses to 'empty' (assumes no wrapping and count > 0).
-		// Returns true if the block is now empty (does not apply in explicit context).
-		template<InnerQueueContext context>
-		inline bool set_many_empty(MOODYCAMEL_MAYBE_UNUSED index_t i, size_t count)
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Set flags
-				std::atomic_thread_fence(std::memory_order_release);
-				i = BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1)) - count + 1;
-				for (size_t j = 0; j != count; ++j) {
-					assert(!emptyFlags[i + j].load(std::memory_order_relaxed));
-					emptyFlags[i + j].store(true, std::memory_order_relaxed);
-				}
-				return false;
-			}
-			else {
-				// Increment counter
-				auto prevVal = elementsCompletelyDequeued.fetch_add(count, std::memory_order_release);
-				assert(prevVal + count <= BLOCK_SIZE);
-				return prevVal + count == BLOCK_SIZE;
-			}
-		}
-		
-		template<InnerQueueContext context>
-		inline void set_all_empty()
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Set all flags
-				for (size_t i = 0; i != BLOCK_SIZE; ++i) {
-					emptyFlags[i].store(true, std::memory_order_relaxed);
-				}
-			}
-			else {
-				// Reset counter
-				elementsCompletelyDequeued.store(BLOCK_SIZE, std::memory_order_relaxed);
-			}
-		}
-		
-		template<InnerQueueContext context>
-		inline void reset_empty()
-		{
-			MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
-				// Reset flags
-				for (size_t i = 0; i != BLOCK_SIZE; ++i) {
-					emptyFlags[i].store(false, std::memory_order_relaxed);
-				}
-			}
-			else {
-				// Reset counter
-				elementsCompletelyDequeued.store(0, std::memory_order_relaxed);
-			}
-		}
-		
-		inline T* operator[](index_t idx) MOODYCAMEL_NOEXCEPT { return static_cast<T*>(static_cast<void*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
-		inline T const* operator[](index_t idx) const MOODYCAMEL_NOEXCEPT { return static_cast<T const*>(static_cast<void const*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
-		
-	private:
-		static_assert(std::alignment_of<T>::value <= sizeof(T), "The queue does not support types with an alignment greater than their size at this time");
-		MOODYCAMEL_ALIGNED_TYPE_LIKE(char[sizeof(T) * BLOCK_SIZE], T) elements;
-	public:
-		Block* next;
-		std::atomic<size_t> elementsCompletelyDequeued;
-		std::atomic<bool> emptyFlags[BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD ? BLOCK_SIZE : 1];
-	public:
-		std::atomic<std::uint32_t> freeListRefs;
-		std::atomic<Block*> freeListNext;
-		bool dynamicallyAllocated;		// Perhaps a better name for this would be 'isNotPartOfInitialBlockPool'
-		
+            owner = nullptr;
+#endif
+        }
+        
+        template<InnerQueueContext context>
+        inline bool is_empty() const
+        {
+            MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
+                // Check flags
+                for (size_t i = 0; i < BLOCK_SIZE; ++i) {
+                    if (!emptyFlags[i].load(std::memory_order_relaxed)) {
+                        return false;
+                    }
+                }
+                
+                // Aha, empty; make sure we have all other memory effects that happened before the empty flags were set
+                std::atomic_thread_fence(std::memory_order_acquire);
+                return true;
+            }
+            else {
+                // Check counter
+                if (elementsCompletelyDequeued.load(std::memory_order_relaxed) == BLOCK_SIZE) {
+                    std::atomic_thread_fence(std::memory_order_acquire);
+                    return true;
+                }
+                assert(elementsCompletelyDequeued.load(std::memory_order_relaxed) <= BLOCK_SIZE);
+                return false;
+            }
+        }
+        
+        // Returns true if the block is now empty (does not apply in explicit context)
+        template<InnerQueueContext context>
+        inline bool set_empty(MOODYCAMEL_MAYBE_UNUSED index_t i)
+        {
+            MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
+                // Set flag
+                assert(!emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].load(std::memory_order_relaxed));
+                emptyFlags[BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1))].store(true, std::memory_order_release);
+                return false;
+            }
+            else {
+                // Increment counter
+                auto prevVal = elementsCompletelyDequeued.fetch_add(1, std::memory_order_release);
+                assert(prevVal < BLOCK_SIZE);
+                return prevVal == BLOCK_SIZE - 1;
+            }
+        }
+        
+        // Sets multiple contiguous item statuses to 'empty' (assumes no wrapping and count > 0).
+        // Returns true if the block is now empty (does not apply in explicit context).
+        template<InnerQueueContext context>
+        inline bool set_many_empty(MOODYCAMEL_MAYBE_UNUSED index_t i, size_t count)
+        {
+            MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
+                // Set flags
+                std::atomic_thread_fence(std::memory_order_release);
+                i = BLOCK_SIZE - 1 - static_cast<size_t>(i & static_cast<index_t>(BLOCK_SIZE - 1)) - count + 1;
+                for (size_t j = 0; j != count; ++j) {
+                    assert(!emptyFlags[i + j].load(std::memory_order_relaxed));
+                    emptyFlags[i + j].store(true, std::memory_order_relaxed);
+                }
+                return false;
+            }
+            else {
+                // Increment counter
+                auto prevVal = elementsCompletelyDequeued.fetch_add(count, std::memory_order_release);
+                assert(prevVal + count <= BLOCK_SIZE);
+                return prevVal + count == BLOCK_SIZE;
+            }
+        }
+        
+        template<InnerQueueContext context>
+        inline void set_all_empty()
+        {
+            MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
+                // Set all flags
+                for (size_t i = 0; i != BLOCK_SIZE; ++i) {
+                    emptyFlags[i].store(true, std::memory_order_relaxed);
+                }
+            }
+            else {
+                // Reset counter
+                elementsCompletelyDequeued.store(BLOCK_SIZE, std::memory_order_relaxed);
+            }
+        }
+        
+        template<InnerQueueContext context>
+        inline void reset_empty()
+        {
+            MOODYCAMEL_CONSTEXPR_IF (context == explicit_context && BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD) {
+                // Reset flags
+                for (size_t i = 0; i != BLOCK_SIZE; ++i) {
+                    emptyFlags[i].store(false, std::memory_order_relaxed);
+                }
+            }
+            else {
+                // Reset counter
+                elementsCompletelyDequeued.store(0, std::memory_order_relaxed);
+            }
+        }
+        
+        inline T* operator[](index_t idx) MOODYCAMEL_NOEXCEPT { return static_cast<T*>(static_cast<void*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
+        inline T const* operator[](index_t idx) const MOODYCAMEL_NOEXCEPT { return static_cast<T const*>(static_cast<void const*>(elements)) + static_cast<size_t>(idx & static_cast<index_t>(BLOCK_SIZE - 1)); }
+        
+    private:
+        static_assert(std::alignment_of<T>::value <= sizeof(T), "The queue does not support types with an alignment greater than their size at this time");
+        MOODYCAMEL_ALIGNED_TYPE_LIKE(char[sizeof(T) * BLOCK_SIZE], T) elements;
+    public:
+        Block* next;
+        std::atomic<size_t> elementsCompletelyDequeued;
+        std::atomic<bool> emptyFlags[BLOCK_SIZE <= EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD ? BLOCK_SIZE : 1];
+    public:
+        std::atomic<std::uint32_t> freeListRefs;
+        std::atomic<Block*> freeListNext;
+        bool dynamicallyAllocated;		// Perhaps a better name for this would be 'isNotPartOfInitialBlockPool'
+        
 #ifdef MCDBGQ_TRACKMEM
-		void* owner;
+        void* owner;
 #endif
-	};
-	static_assert(std::alignment_of<Block>::value >= std::alignment_of<T>::value, "Internal error: Blocks must be at least as aligned as the type they are wrapping");
+    };
+    static_assert(std::alignment_of<Block>::value >= std::alignment_of<T>::value, "Internal error: Blocks must be at least as aligned as the type they are wrapping");
 
 
 #ifdef MCDBGQ_TRACKMEM
 public:
-	struct MemStats;
+    struct MemStats;
 private:
 #endif
-	
-	///////////////////////////
-	// Producer base
-	///////////////////////////
-	
-	struct ProducerBase : public details::ConcurrentQueueProducerTypelessBase
-	{
-		ProducerBase(ConcurrentQueue* parent_, bool isExplicit_) :
-			tailIndex(0),
-			headIndex(0),
-			dequeueOptimisticCount(0),
-			dequeueOvercommit(0),
-			tailBlock(nullptr),
-			isExplicit(isExplicit_),
-			parent(parent_)
-		{
-		}
-		
-		virtual ~ProducerBase() { }
-		
-		template<typename U>
-		inline bool dequeue(U& element)
-		{
-			if (isExplicit) {
-				return static_cast<ExplicitProducer*>(this)->dequeue(element);
-			}
-			else {
-				return static_cast<ImplicitProducer*>(this)->dequeue(element);
-			}
-		}
-		
-		template<typename It>
-		inline size_t dequeue_bulk(It& itemFirst, size_t max)
-		{
-			if (isExplicit) {
-				return static_cast<ExplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
-			}
-			else {
-				return static_cast<ImplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
-			}
-		}
-		
-		inline ProducerBase* next_prod() const { return static_cast<ProducerBase*>(next); }
-		
-		inline size_t size_approx() const
-		{
-			auto tail = tailIndex.load(std::memory_order_relaxed);
-			auto head = headIndex.load(std::memory_order_relaxed);
-			return details::circular_less_than(head, tail) ? static_cast<size_t>(tail - head) : 0;
-		}
-		
-		inline index_t getTail() const { return tailIndex.load(std::memory_order_relaxed); }
-	protected:
-		std::atomic<index_t> tailIndex;		// Where to enqueue to next
-		std::atomic<index_t> headIndex;		// Where to dequeue from next
-		
-		std::atomic<index_t> dequeueOptimisticCount;
-		std::atomic<index_t> dequeueOvercommit;
-		
-		Block* tailBlock;
-		
-	public:
-		bool isExplicit;
-		ConcurrentQueue* parent;
-		
-	protected:
+    
+    ///////////////////////////
+    // Producer base
+    ///////////////////////////
+    
+    struct ProducerBase : public details::ConcurrentQueueProducerTypelessBase
+    {
+        ProducerBase(ConcurrentQueue* parent_, bool isExplicit_) :
+            tailIndex(0),
+            headIndex(0),
+            dequeueOptimisticCount(0),
+            dequeueOvercommit(0),
+            tailBlock(nullptr),
+            isExplicit(isExplicit_),
+            parent(parent_)
+        {
+        }
+        
+        virtual ~ProducerBase() { }
+        
+        template<typename U>
+        inline bool dequeue(U& element)
+        {
+            if (isExplicit) {
+                return static_cast<ExplicitProducer*>(this)->dequeue(element);
+            }
+            else {
+                return static_cast<ImplicitProducer*>(this)->dequeue(element);
+            }
+        }
+        
+        template<typename It>
+        inline size_t dequeue_bulk(It& itemFirst, size_t max)
+        {
+            if (isExplicit) {
+                return static_cast<ExplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
+            }
+            else {
+                return static_cast<ImplicitProducer*>(this)->dequeue_bulk(itemFirst, max);
+            }
+        }
+        
+        inline ProducerBase* next_prod() const { return static_cast<ProducerBase*>(next); }
+        
+        inline size_t size_approx() const
+        {
+            auto tail = tailIndex.load(std::memory_order_relaxed);
+            auto head = headIndex.load(std::memory_order_relaxed);
+            return details::circular_less_than(head, tail) ? static_cast<size_t>(tail - head) : 0;
+        }
+        
+        inline index_t getTail() const { return tailIndex.load(std::memory_order_relaxed); }
+    protected:
+        std::atomic<index_t> tailIndex;		// Where to enqueue to next
+        std::atomic<index_t> headIndex;		// Where to dequeue from next
+        
+        std::atomic<index_t> dequeueOptimisticCount;
+        std::atomic<index_t> dequeueOvercommit;
+        
+        Block* tailBlock;
+        
+    public:
+        bool isExplicit;
+        ConcurrentQueue* parent;
+        
+    protected:
 #ifdef MCDBGQ_TRACKMEM
-		friend struct MemStats;
-#endif
-	};
-	
-	
-	///////////////////////////
-	// Explicit queue
-	///////////////////////////
-		
-	struct ExplicitProducer : public ProducerBase
-	{
-		explicit ExplicitProducer(ConcurrentQueue* parent_) :
-			ProducerBase(parent_, true),
-			blockIndex(nullptr),
-			pr_blockIndexSlotsUsed(0),
-			pr_blockIndexSize(EXPLICIT_INITIAL_INDEX_SIZE >> 1),
-			pr_blockIndexFront(0),
-			pr_blockIndexEntries(nullptr),
-			pr_blockIndexRaw(nullptr)
-		{
-			size_t poolBasedIndexSize = details::ceil_to_pow_2(parent_->initialBlockPoolSize) >> 1;
-			if (poolBasedIndexSize > pr_blockIndexSize) {
-				pr_blockIndexSize = poolBasedIndexSize;
-			}
-			
-			new_block_index(0);		// This creates an index with double the number of current entries, i.e. EXPLICIT_INITIAL_INDEX_SIZE
-		}
-		
-		~ExplicitProducer()
-		{
-			// Destruct any elements not yet dequeued.
-			// Since we're in the destructor, we can assume all elements
-			// are either completely dequeued or completely not (no halfways).
-			if (this->tailBlock != nullptr) {		// Note this means there must be a block index too
-				// First find the block that's partially dequeued, if any
-				Block* halfDequeuedBlock = nullptr;
-				if ((this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) != 0) {
-					// The head's not on a block boundary, meaning a block somewhere is partially dequeued
-					// (or the head block is the tail block and was fully dequeued, but the head/tail are still not on a boundary)
-					size_t i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & (pr_blockIndexSize - 1);
-					while (details::circular_less_than<index_t>(pr_blockIndexEntries[i].base + BLOCK_SIZE, this->headIndex.load(std::memory_order_relaxed))) {
-						i = (i + 1) & (pr_blockIndexSize - 1);
-					}
-					assert(details::circular_less_than<index_t>(pr_blockIndexEntries[i].base, this->headIndex.load(std::memory_order_relaxed)));
-					halfDequeuedBlock = pr_blockIndexEntries[i].block;
-				}
-				
-				// Start at the head block (note the first line in the loop gives us the head from the tail on the first iteration)
-				auto block = this->tailBlock;
-				do {
-					block = block->next;
-					if (block->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
-						continue;
-					}
-					
-					size_t i = 0;	// Offset into block
-					if (block == halfDequeuedBlock) {
-						i = static_cast<size_t>(this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
-					}
-					
-					// Walk through all the items in the block; if this is the tail block, we need to stop when we reach the tail index
-					auto lastValidIndex = (this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 ? BLOCK_SIZE : static_cast<size_t>(this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
-					while (i != BLOCK_SIZE && (block != this->tailBlock || i != lastValidIndex)) {
-						(*block)[i++]->~T();
-					}
-				} while (block != this->tailBlock);
-			}
-			
-			// Destroy all blocks that we own
-			if (this->tailBlock != nullptr) {
-				auto block = this->tailBlock;
-				do {
-					auto nextBlock = block->next;
-					this->parent->add_block_to_free_list(block);
-					block = nextBlock;
-				} while (block != this->tailBlock);
-			}
-			
-			// Destroy the block indices
-			auto header = static_cast<BlockIndexHeader*>(pr_blockIndexRaw);
-			while (header != nullptr) {
-				auto prev = static_cast<BlockIndexHeader*>(header->prev);
-				header->~BlockIndexHeader();
-				(Traits::free)(header);
-				header = prev;
-			}
-		}
-		
-		template<AllocationMode allocMode, typename U>
-		inline bool enqueue(U&& element)
-		{
-			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			index_t newTailIndex = 1 + currentTailIndex;
-			if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-				// We reached the end of a block, start a new one
-				auto startBlock = this->tailBlock;
-				auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
-				if (this->tailBlock != nullptr && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
-					// We can re-use the block ahead of us, it's empty!					
-					this->tailBlock = this->tailBlock->next;
-					this->tailBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
-					
-					// We'll put the block on the block index (guaranteed to be room since we're conceptually removing the
-					// last block from it first -- except instead of removing then adding, we can just overwrite).
-					// Note that there must be a valid block index here, since even if allocation failed in the ctor,
-					// it would have been re-attempted when adding the first block to the queue; since there is such
-					// a block, a block index must have been successfully allocated.
-				}
-				else {
-					// Whatever head value we see here is >= the last value we saw here (relatively),
-					// and <= its current value. Since we have the most recent tail, the head must be
-					// <= to it.
-					auto head = this->headIndex.load(std::memory_order_relaxed);
-					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-					if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE)
-						|| (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
-						// We can't enqueue in another block because there's not enough leeway -- the
-						// tail could surpass the head by the time the block fills up! (Or we'll exceed
-						// the size limit, if the second part of the condition was true.)
-						return false;
-					}
-					// We're going to need a new block; check that the block index has room
-					if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize) {
-						// Hmm, the circular block index is already full -- we'll need
-						// to allocate a new index. Note pr_blockIndexRaw can only be nullptr if
-						// the initial allocation failed in the constructor.
-						
-						MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
-							return false;
-						}
-						else if (!new_block_index(pr_blockIndexSlotsUsed)) {
-							return false;
-						}
-					}
-					
-					// Insert a new block in the circular linked list
-					auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
-					if (newBlock == nullptr) {
-						return false;
-					}
+        friend struct MemStats;
+#endif
+    };
+    
+    
+    ///////////////////////////
+    // Explicit queue
+    ///////////////////////////
+        
+    struct ExplicitProducer : public ProducerBase
+    {
+        explicit ExplicitProducer(ConcurrentQueue* parent_) :
+            ProducerBase(parent_, true),
+            blockIndex(nullptr),
+            pr_blockIndexSlotsUsed(0),
+            pr_blockIndexSize(EXPLICIT_INITIAL_INDEX_SIZE >> 1),
+            pr_blockIndexFront(0),
+            pr_blockIndexEntries(nullptr),
+            pr_blockIndexRaw(nullptr)
+        {
+            size_t poolBasedIndexSize = details::ceil_to_pow_2(parent_->initialBlockPoolSize) >> 1;
+            if (poolBasedIndexSize > pr_blockIndexSize) {
+                pr_blockIndexSize = poolBasedIndexSize;
+            }
+            
+            new_block_index(0);		// This creates an index with double the number of current entries, i.e. EXPLICIT_INITIAL_INDEX_SIZE
+        }
+        
+        ~ExplicitProducer()
+        {
+            // Destruct any elements not yet dequeued.
+            // Since we're in the destructor, we can assume all elements
+            // are either completely dequeued or completely not (no halfways).
+            if (this->tailBlock != nullptr) {		// Note this means there must be a block index too
+                // First find the block that's partially dequeued, if any
+                Block* halfDequeuedBlock = nullptr;
+                if ((this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) != 0) {
+                    // The head's not on a block boundary, meaning a block somewhere is partially dequeued
+                    // (or the head block is the tail block and was fully dequeued, but the head/tail are still not on a boundary)
+                    size_t i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & (pr_blockIndexSize - 1);
+                    while (details::circular_less_than<index_t>(pr_blockIndexEntries[i].base + BLOCK_SIZE, this->headIndex.load(std::memory_order_relaxed))) {
+                        i = (i + 1) & (pr_blockIndexSize - 1);
+                    }
+                    assert(details::circular_less_than<index_t>(pr_blockIndexEntries[i].base, this->headIndex.load(std::memory_order_relaxed)));
+                    halfDequeuedBlock = pr_blockIndexEntries[i].block;
+                }
+                
+                // Start at the head block (note the first line in the loop gives us the head from the tail on the first iteration)
+                auto block = this->tailBlock;
+                do {
+                    block = block->next;
+                    if (block->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
+                        continue;
+                    }
+                    
+                    size_t i = 0;	// Offset into block
+                    if (block == halfDequeuedBlock) {
+                        i = static_cast<size_t>(this->headIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
+                    }
+                    
+                    // Walk through all the items in the block; if this is the tail block, we need to stop when we reach the tail index
+                    auto lastValidIndex = (this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 ? BLOCK_SIZE : static_cast<size_t>(this->tailIndex.load(std::memory_order_relaxed) & static_cast<index_t>(BLOCK_SIZE - 1));
+                    while (i != BLOCK_SIZE && (block != this->tailBlock || i != lastValidIndex)) {
+                        (*block)[i++]->~T();
+                    }
+                } while (block != this->tailBlock);
+            }
+            
+            // Destroy all blocks that we own
+            if (this->tailBlock != nullptr) {
+                auto block = this->tailBlock;
+                do {
+                    auto nextBlock = block->next;
+                    this->parent->add_block_to_free_list(block);
+                    block = nextBlock;
+                } while (block != this->tailBlock);
+            }
+            
+            // Destroy the block indices
+            auto header = static_cast<BlockIndexHeader*>(pr_blockIndexRaw);
+            while (header != nullptr) {
+                auto prev = static_cast<BlockIndexHeader*>(header->prev);
+                header->~BlockIndexHeader();
+                (Traits::free)(header);
+                header = prev;
+            }
+        }
+        
+        template<AllocationMode allocMode, typename U>
+        inline bool enqueue(U&& element)
+        {
+            index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
+            index_t newTailIndex = 1 + currentTailIndex;
+            if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
+                // We reached the end of a block, start a new one
+                auto startBlock = this->tailBlock;
+                auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
+                if (this->tailBlock != nullptr && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
+                    // We can re-use the block ahead of us, it's empty!					
+                    this->tailBlock = this->tailBlock->next;
+                    this->tailBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
+                    
+                    // We'll put the block on the block index (guaranteed to be room since we're conceptually removing the
+                    // last block from it first -- except instead of removing then adding, we can just overwrite).
+                    // Note that there must be a valid block index here, since even if allocation failed in the ctor,
+                    // it would have been re-attempted when adding the first block to the queue; since there is such
+                    // a block, a block index must have been successfully allocated.
+                }
+                else {
+                    // Whatever head value we see here is >= the last value we saw here (relatively),
+                    // and <= its current value. Since we have the most recent tail, the head must be
+                    // <= to it.
+                    auto head = this->headIndex.load(std::memory_order_relaxed);
+                    assert(!details::circular_less_than<index_t>(currentTailIndex, head));
+                    if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE)
+                        || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
+                        // We can't enqueue in another block because there's not enough leeway -- the
+                        // tail could surpass the head by the time the block fills up! (Or we'll exceed
+                        // the size limit, if the second part of the condition was true.)
+                        return false;
+                    }
+                    // We're going to need a new block; check that the block index has room
+                    if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize) {
+                        // Hmm, the circular block index is already full -- we'll need
+                        // to allocate a new index. Note pr_blockIndexRaw can only be nullptr if
+                        // the initial allocation failed in the constructor.
+                        
+                        MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
+                            return false;
+                        }
+                        else if (!new_block_index(pr_blockIndexSlotsUsed)) {
+                            return false;
+                        }
+                    }
+                    
+                    // Insert a new block in the circular linked list
+                    auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
+                    if (newBlock == nullptr) {
+                        return false;
+                    }
 #ifdef MCDBGQ_TRACKMEM
-					newBlock->owner = this;
-#endif
-					newBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
-					if (this->tailBlock == nullptr) {
-						newBlock->next = newBlock;
-					}
-					else {
-						newBlock->next = this->tailBlock->next;
-						this->tailBlock->next = newBlock;
-					}
-					this->tailBlock = newBlock;
-					++pr_blockIndexSlotsUsed;
-				}
-
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
-					// The constructor may throw. We want the element not to appear in the queue in
-					// that case (without corrupting the queue):
-					MOODYCAMEL_TRY {
-						new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
-					}
-					MOODYCAMEL_CATCH (...) {
-						// Revert change to the current block, but leave the new block available
-						// for next time
-						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-						this->tailBlock = startBlock == nullptr ? this->tailBlock : startBlock;
-						MOODYCAMEL_RETHROW;
-					}
-				}
-				else {
-					(void)startBlock;
-					(void)originalBlockIndexSlotsUsed;
-				}
-				
-				// Add block to block index
-				auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
-				entry.base = currentTailIndex;
-				entry.block = this->tailBlock;
-				blockIndex.load(std::memory_order_relaxed)->front.store(pr_blockIndexFront, std::memory_order_release);
-				pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
-				
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
-					this->tailIndex.store(newTailIndex, std::memory_order_release);
-					return true;
-				}
-			}
-			
-			// Enqueue
-			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
-			
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-		
-		template<typename U>
-		bool dequeue(U& element)
-		{
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
-				// Might be something to dequeue, let's give it a try
-				
-				// Note that this if is purely for performance purposes in the common case when the queue is
-				// empty and the values are eventually consistent -- we may enter here spuriously.
-				
-				// Note that whatever the values of overcommit and tail are, they are not going to change (unless we
-				// change them) and must be the same value at this point (inside the if) as when the if condition was
-				// evaluated.
-
-				// We insert an acquire fence here to synchronize-with the release upon incrementing dequeueOvercommit below.
-				// This ensures that whatever the value we got loaded into overcommit, the load of dequeueOptisticCount in
-				// the fetch_add below will result in a value at least as recent as that (and therefore at least as large).
-				// Note that I believe a compiler (signal) fence here would be sufficient due to the nature of fetch_add (all
-				// read-modify-write operations are guaranteed to work on the latest value in the modification order), but
-				// unfortunately that can't be shown to be correct using only the C++11 standard.
-				// See http://stackoverflow.com/questions/18223161/what-are-the-c11-memory-ordering-guarantees-in-this-corner-case
-				std::atomic_thread_fence(std::memory_order_acquire);
-				
-				// Increment optimistic counter, then check if it went over the boundary
-				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
-				
-				// Note that since dequeueOvercommit must be <= dequeueOptimisticCount (because dequeueOvercommit is only ever
-				// incremented after dequeueOptimisticCount -- this is enforced in the `else` block below), and since we now
-				// have a version of dequeueOptimisticCount that is at least as recent as overcommit (due to the release upon
-				// incrementing dequeueOvercommit and the acquire above that synchronizes with it), overcommit <= myDequeueCount.
-				// However, we can't assert this since both dequeueOptimisticCount and dequeueOvercommit may (independently)
-				// overflow; in such a case, though, the logic still holds since the difference between the two is maintained.
-				
-				// Note that we reload tail here in case it changed; it will be the same value as before or greater, since
-				// this load is sequenced after (happens after) the earlier load above. This is supported by read-read
-				// coherency (as defined in the standard), explained here: http://en.cppreference.com/w/cpp/atomic/memory_order
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				if ((details::likely)(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
-					// Guaranteed to be at least one element to dequeue!
-					
-					// Get the index. Note that since there's guaranteed to be at least one element, this
-					// will never exceed tail. We need to do an acquire-release fence here since it's possible
-					// that whatever condition got us to this point was for an earlier enqueued element (that
-					// we already see the memory effects for), but that by the time we increment somebody else
-					// has incremented it, and we need to see the memory effects for *that* element, which is
-					// in such a case is necessarily visible on the thread that incremented it in the first
-					// place with the more current condition (they must have acquired a tail that is at least
-					// as recent).
-					auto index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
-					
-					
-					// Determine which block the element is in
-					
-					auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
-					auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
-					
-					// We need to be careful here about subtracting and dividing because of index wrap-around.
-					// When an index wraps, we need to preserve the sign of the offset when dividing it by the
-					// block size (in order to get a correct signed block count offset in all cases):
-					auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
-					auto blockBaseIndex = index & ~static_cast<index_t>(BLOCK_SIZE - 1);
-					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(blockBaseIndex - headBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
-					auto block = localBlockIndex->entries[(localBlockIndexHead + offset) & (localBlockIndex->size - 1)].block;
-					
-					// Dequeue
-					auto& el = *((*block)[index]);
-					if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
-						// Make sure the element is still fully dequeued and destroyed even if the assignment
-						// throws
-						struct Guard {
-							Block* block;
-							index_t index;
-							
-							~Guard()
-							{
-								(*block)[index]->~T();
-								block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
-							}
-						} guard = { block, index };
-
-						element = std::move(el); // NOLINT
-					}
-					else {
-						element = std::move(el); // NOLINT
-						el.~T(); // NOLINT
-						block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
-					}
-					
-					return true;
-				}
-				else {
-					// Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
-					this->dequeueOvercommit.fetch_add(1, std::memory_order_release);		// Release so that the fetch_add on dequeueOptimisticCount is guaranteed to happen before this write
-				}
-			}
-		
-			return false;
-		}
-		
-		template<AllocationMode allocMode, typename It>
-		bool MOODYCAMEL_NO_TSAN enqueue_bulk(It itemFirst, size_t count)
-		{
-			// First, we need to make sure we have enough room to enqueue all of the elements;
-			// this means pre-allocating blocks and putting them in the block index (but only if
-			// all the allocations succeeded).
-			index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			auto startBlock = this->tailBlock;
-			auto originalBlockIndexFront = pr_blockIndexFront;
-			auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
-			
-			Block* firstAllocatedBlock = nullptr;
-			
-			// Figure out how many blocks we'll need to allocate, and do so
-			size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
-			index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-			if (blockBaseDiff > 0) {
-				// Allocate as many blocks as possible from ahead
-				while (blockBaseDiff > 0 && this->tailBlock != nullptr && this->tailBlock->next != firstAllocatedBlock && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
-					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
-					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-					
-					this->tailBlock = this->tailBlock->next;
-					firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
-					
-					auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
-					entry.base = currentTailIndex;
-					entry.block = this->tailBlock;
-					pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
-				}
-				
-				// Now allocate as many blocks as necessary from the block pool
-				while (blockBaseDiff > 0) {
-					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
-					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-					
-					auto head = this->headIndex.load(std::memory_order_relaxed);
-					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-					bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
-					if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize || full) {
-						MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
-							// Failed to allocate, undo changes (but keep injected blocks)
-							pr_blockIndexFront = originalBlockIndexFront;
-							pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-							this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-							return false;
-						}
-						else if (full || !new_block_index(originalBlockIndexSlotsUsed)) {
-							// Failed to allocate, undo changes (but keep injected blocks)
-							pr_blockIndexFront = originalBlockIndexFront;
-							pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-							this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-							return false;
-						}
-						
-						// pr_blockIndexFront is updated inside new_block_index, so we need to
-						// update our fallback value too (since we keep the new index even if we
-						// later fail)
-						originalBlockIndexFront = originalBlockIndexSlotsUsed;
-					}
-					
-					// Insert a new block in the circular linked list
-					auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
-					if (newBlock == nullptr) {
-						pr_blockIndexFront = originalBlockIndexFront;
-						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-						this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-						return false;
-					}
-					
+                    newBlock->owner = this;
+#endif
+                    newBlock->ConcurrentQueue::Block::template reset_empty<explicit_context>();
+                    if (this->tailBlock == nullptr) {
+                        newBlock->next = newBlock;
+                    }
+                    else {
+                        newBlock->next = this->tailBlock->next;
+                        this->tailBlock->next = newBlock;
+                    }
+                    this->tailBlock = newBlock;
+                    ++pr_blockIndexSlotsUsed;
+                }
+
+                MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
+                    // The constructor may throw. We want the element not to appear in the queue in
+                    // that case (without corrupting the queue):
+                    MOODYCAMEL_TRY {
+                        new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
+                    }
+                    MOODYCAMEL_CATCH (...) {
+                        // Revert change to the current block, but leave the new block available
+                        // for next time
+                        pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
+                        this->tailBlock = startBlock == nullptr ? this->tailBlock : startBlock;
+                        MOODYCAMEL_RETHROW;
+                    }
+                }
+                else {
+                    (void)startBlock;
+                    (void)originalBlockIndexSlotsUsed;
+                }
+                
+                // Add block to block index
+                auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
+                entry.base = currentTailIndex;
+                entry.block = this->tailBlock;
+                blockIndex.load(std::memory_order_relaxed)->front.store(pr_blockIndexFront, std::memory_order_release);
+                pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
+                
+                MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
+                    this->tailIndex.store(newTailIndex, std::memory_order_release);
+                    return true;
+                }
+            }
+            
+            // Enqueue
+            new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
+            
+            this->tailIndex.store(newTailIndex, std::memory_order_release);
+            return true;
+        }
+        
+        template<typename U>
+        bool dequeue(U& element)
+        {
+            auto tail = this->tailIndex.load(std::memory_order_relaxed);
+            auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
+            if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
+                // Might be something to dequeue, let's give it a try
+                
+                // Note that this if is purely for performance purposes in the common case when the queue is
+                // empty and the values are eventually consistent -- we may enter here spuriously.
+                
+                // Note that whatever the values of overcommit and tail are, they are not going to change (unless we
+                // change them) and must be the same value at this point (inside the if) as when the if condition was
+                // evaluated.
+
+                // We insert an acquire fence here to synchronize-with the release upon incrementing dequeueOvercommit below.
+                // This ensures that whatever the value we got loaded into overcommit, the load of dequeueOptisticCount in
+                // the fetch_add below will result in a value at least as recent as that (and therefore at least as large).
+                // Note that I believe a compiler (signal) fence here would be sufficient due to the nature of fetch_add (all
+                // read-modify-write operations are guaranteed to work on the latest value in the modification order), but
+                // unfortunately that can't be shown to be correct using only the C++11 standard.
+                // See http://stackoverflow.com/questions/18223161/what-are-the-c11-memory-ordering-guarantees-in-this-corner-case
+                std::atomic_thread_fence(std::memory_order_acquire);
+                
+                // Increment optimistic counter, then check if it went over the boundary
+                auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
+                
+                // Note that since dequeueOvercommit must be <= dequeueOptimisticCount (because dequeueOvercommit is only ever
+                // incremented after dequeueOptimisticCount -- this is enforced in the `else` block below), and since we now
+                // have a version of dequeueOptimisticCount that is at least as recent as overcommit (due to the release upon
+                // incrementing dequeueOvercommit and the acquire above that synchronizes with it), overcommit <= myDequeueCount.
+                // However, we can't assert this since both dequeueOptimisticCount and dequeueOvercommit may (independently)
+                // overflow; in such a case, though, the logic still holds since the difference between the two is maintained.
+                
+                // Note that we reload tail here in case it changed; it will be the same value as before or greater, since
+                // this load is sequenced after (happens after) the earlier load above. This is supported by read-read
+                // coherency (as defined in the standard), explained here: http://en.cppreference.com/w/cpp/atomic/memory_order
+                tail = this->tailIndex.load(std::memory_order_acquire);
+                if ((details::likely)(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
+                    // Guaranteed to be at least one element to dequeue!
+                    
+                    // Get the index. Note that since there's guaranteed to be at least one element, this
+                    // will never exceed tail. We need to do an acquire-release fence here since it's possible
+                    // that whatever condition got us to this point was for an earlier enqueued element (that
+                    // we already see the memory effects for), but that by the time we increment somebody else
+                    // has incremented it, and we need to see the memory effects for *that* element, which is
+                    // in such a case is necessarily visible on the thread that incremented it in the first
+                    // place with the more current condition (they must have acquired a tail that is at least
+                    // as recent).
+                    auto index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
+                    
+                    
+                    // Determine which block the element is in
+                    
+                    auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
+                    auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
+                    
+                    // We need to be careful here about subtracting and dividing because of index wrap-around.
+                    // When an index wraps, we need to preserve the sign of the offset when dividing it by the
+                    // block size (in order to get a correct signed block count offset in all cases):
+                    auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
+                    auto blockBaseIndex = index & ~static_cast<index_t>(BLOCK_SIZE - 1);
+                    auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(blockBaseIndex - headBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
+                    auto block = localBlockIndex->entries[(localBlockIndexHead + offset) & (localBlockIndex->size - 1)].block;
+                    
+                    // Dequeue
+                    auto& el = *((*block)[index]);
+                    if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
+                        // Make sure the element is still fully dequeued and destroyed even if the assignment
+                        // throws
+                        struct Guard {
+                            Block* block;
+                            index_t index;
+                            
+                            ~Guard()
+                            {
+                                (*block)[index]->~T();
+                                block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
+                            }
+                        } guard = { block, index };
+
+                        element = std::move(el); // NOLINT
+                    }
+                    else {
+                        element = std::move(el); // NOLINT
+                        el.~T(); // NOLINT
+                        block->ConcurrentQueue::Block::template set_empty<explicit_context>(index);
+                    }
+                    
+                    return true;
+                }
+                else {
+                    // Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
+                    this->dequeueOvercommit.fetch_add(1, std::memory_order_release);		// Release so that the fetch_add on dequeueOptimisticCount is guaranteed to happen before this write
+                }
+            }
+        
+            return false;
+        }
+        
+        template<AllocationMode allocMode, typename It>
+        bool MOODYCAMEL_NO_TSAN enqueue_bulk(It itemFirst, size_t count)
+        {
+            // First, we need to make sure we have enough room to enqueue all of the elements;
+            // this means pre-allocating blocks and putting them in the block index (but only if
+            // all the allocations succeeded).
+            index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
+            auto startBlock = this->tailBlock;
+            auto originalBlockIndexFront = pr_blockIndexFront;
+            auto originalBlockIndexSlotsUsed = pr_blockIndexSlotsUsed;
+            
+            Block* firstAllocatedBlock = nullptr;
+            
+            // Figure out how many blocks we'll need to allocate, and do so
+            size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
+            index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
+            if (blockBaseDiff > 0) {
+                // Allocate as many blocks as possible from ahead
+                while (blockBaseDiff > 0 && this->tailBlock != nullptr && this->tailBlock->next != firstAllocatedBlock && this->tailBlock->next->ConcurrentQueue::Block::template is_empty<explicit_context>()) {
+                    blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
+                    currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
+                    
+                    this->tailBlock = this->tailBlock->next;
+                    firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
+                    
+                    auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
+                    entry.base = currentTailIndex;
+                    entry.block = this->tailBlock;
+                    pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
+                }
+                
+                // Now allocate as many blocks as necessary from the block pool
+                while (blockBaseDiff > 0) {
+                    blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
+                    currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
+                    
+                    auto head = this->headIndex.load(std::memory_order_relaxed);
+                    assert(!details::circular_less_than<index_t>(currentTailIndex, head));
+                    bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
+                    if (pr_blockIndexRaw == nullptr || pr_blockIndexSlotsUsed == pr_blockIndexSize || full) {
+                        MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
+                            // Failed to allocate, undo changes (but keep injected blocks)
+                            pr_blockIndexFront = originalBlockIndexFront;
+                            pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
+                            this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
+                            return false;
+                        }
+                        else if (full || !new_block_index(originalBlockIndexSlotsUsed)) {
+                            // Failed to allocate, undo changes (but keep injected blocks)
+                            pr_blockIndexFront = originalBlockIndexFront;
+                            pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
+                            this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
+                            return false;
+                        }
+                        
+                        // pr_blockIndexFront is updated inside new_block_index, so we need to
+                        // update our fallback value too (since we keep the new index even if we
+                        // later fail)
+                        originalBlockIndexFront = originalBlockIndexSlotsUsed;
+                    }
+                    
+                    // Insert a new block in the circular linked list
+                    auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
+                    if (newBlock == nullptr) {
+                        pr_blockIndexFront = originalBlockIndexFront;
+                        pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
+                        this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
+                        return false;
+                    }
+                    
 #ifdef MCDBGQ_TRACKMEM
-					newBlock->owner = this;
-#endif
-					newBlock->ConcurrentQueue::Block::template set_all_empty<explicit_context>();
-					if (this->tailBlock == nullptr) {
-						newBlock->next = newBlock;
-					}
-					else {
-						newBlock->next = this->tailBlock->next;
-						this->tailBlock->next = newBlock;
-					}
-					this->tailBlock = newBlock;
-					firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
-					
-					++pr_blockIndexSlotsUsed;
-					
-					auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
-					entry.base = currentTailIndex;
-					entry.block = this->tailBlock;
-					pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
-				}
-				
-				// Excellent, all allocations succeeded. Reset each block's emptiness before we fill them up, and
-				// publish the new block index front
-				auto block = firstAllocatedBlock;
-				while (true) {
-					block->ConcurrentQueue::Block::template reset_empty<explicit_context>();
-					if (block == this->tailBlock) {
-						break;
-					}
-					block = block->next;
-				}
-				
-				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
-					blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
-				}
-			}
-			
-			// Enqueue, one block at a time
-			index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
-			currentTailIndex = startTailIndex;
-			auto endBlock = this->tailBlock;
-			this->tailBlock = startBlock;
-			assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
-			if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
-				this->tailBlock = firstAllocatedBlock;
-			}
-			while (true) {
-				index_t stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
-					stopIndex = newTailIndex;
-				}
-				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
-					while (currentTailIndex != stopIndex) {
-						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
-					}
-				}
-				else {
-					MOODYCAMEL_TRY {
-						while (currentTailIndex != stopIndex) {
-							// Must use copy constructor even if move constructor is available
-							// because we may have to revert if there's an exception.
-							// Sorry about the horrible templated next line, but it was the only way
-							// to disable moving *at compile time*, which is important because a type
-							// may only define a (noexcept) move constructor, and so calls to the
-							// cctor will not compile, even if they are in an if branch that will never
-							// be executed
-							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
-							++currentTailIndex;
-							++itemFirst;
-						}
-					}
-					MOODYCAMEL_CATCH (...) {
-						// Oh dear, an exception's been thrown -- destroy the elements that
-						// were enqueued so far and revert the entire bulk operation (we'll keep
-						// any allocated blocks in our linked list for later, though).
-						auto constructedStopIndex = currentTailIndex;
-						auto lastBlockEnqueued = this->tailBlock;
-						
-						pr_blockIndexFront = originalBlockIndexFront;
-						pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
-						this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
-						
-						if (!details::is_trivially_destructible<T>::value) {
-							auto block = startBlock;
-							if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-								block = firstAllocatedBlock;
-							}
-							currentTailIndex = startTailIndex;
-							while (true) {
-								stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-								if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
-									stopIndex = constructedStopIndex;
-								}
-								while (currentTailIndex != stopIndex) {
-									(*block)[currentTailIndex++]->~T();
-								}
-								if (block == lastBlockEnqueued) {
-									break;
-								}
-								block = block->next;
-							}
-						}
-						MOODYCAMEL_RETHROW;
-					}
-				}
-				
-				if (this->tailBlock == endBlock) {
-					assert(currentTailIndex == newTailIndex);
-					break;
-				}
-				this->tailBlock = this->tailBlock->next;
-			}
-			
-			MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
-				if (firstAllocatedBlock != nullptr)
-					blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
-			}
-			
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-		
-		template<typename It>
-		size_t dequeue_bulk(It& itemFirst, size_t max)
-		{
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
-			if (details::circular_less_than<size_t>(0, desiredCount)) {
-				desiredCount = desiredCount < max ? desiredCount : max;
-				std::atomic_thread_fence(std::memory_order_acquire);
-				
-				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);
-				
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
-				if (details::circular_less_than<size_t>(0, actualCount)) {
-					actualCount = desiredCount < actualCount ? desiredCount : actualCount;
-					if (actualCount < desiredCount) {
-						this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
-					}
-					
-					// Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
-					// will never exceed tail.
-					auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
-					
-					// Determine which block the first element is in
-					auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
-					auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
-					
-					auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
-					auto firstBlockBaseIndex = firstIndex & ~static_cast<index_t>(BLOCK_SIZE - 1);
-					auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(firstBlockBaseIndex - headBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
-					auto indexIndex = (localBlockIndexHead + offset) & (localBlockIndex->size - 1);
-					
-					// Iterate the blocks and dequeue
-					auto index = firstIndex;
-					do {
-						auto firstIndexInBlock = index;
-						index_t endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-						endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-						auto block = localBlockIndex->entries[indexIndex].block;
-						if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
-							while (index != endIndex) {
-								auto& el = *((*block)[index]);
-								*itemFirst++ = std::move(el);
-								el.~T();
-								++index;
-							}
-						}
-						else {
-							MOODYCAMEL_TRY {
-								while (index != endIndex) {
-									auto& el = *((*block)[index]);
-									*itemFirst = std::move(el);
-									++itemFirst;
-									el.~T();
-									++index;
-								}
-							}
-							MOODYCAMEL_CATCH (...) {
-								// It's too late to revert the dequeue, but we can make sure that all
-								// the dequeued objects are properly destroyed and the block index
-								// (and empty count) are properly updated before we propagate the exception
-								do {
-									block = localBlockIndex->entries[indexIndex].block;
-									while (index != endIndex) {
-										(*block)[index++]->~T();
-									}
-									block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
-									indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
-									
-									firstIndexInBlock = index;
-									endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-									endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-								} while (index != firstIndex + actualCount);
-								
-								MOODYCAMEL_RETHROW;
-							}
-						}
-						block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
-						indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
-					} while (index != firstIndex + actualCount);
-					
-					return actualCount;
-				}
-				else {
-					// Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
-					this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
-				}
-			}
-			
-			return 0;
-		}
-		
-	private:
-		struct BlockIndexEntry
-		{
-			index_t base;
-			Block* block;
-		};
-		
-		struct BlockIndexHeader
-		{
-			size_t size;
-			std::atomic<size_t> front;		// Current slot (not next, like pr_blockIndexFront)
-			BlockIndexEntry* entries;
-			void* prev;
-		};
-		
-		
-		bool new_block_index(size_t numberOfFilledSlotsToExpose)
-		{
-			auto prevBlockSizeMask = pr_blockIndexSize - 1;
-			
-			// Create the new block
-			pr_blockIndexSize <<= 1;
-			auto newRawPtr = static_cast<char*>((Traits::malloc)(sizeof(BlockIndexHeader) + std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * pr_blockIndexSize));
-			if (newRawPtr == nullptr) {
-				pr_blockIndexSize >>= 1;		// Reset to allow graceful retry
-				return false;
-			}
-			
-			auto newBlockIndexEntries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(newRawPtr + sizeof(BlockIndexHeader)));
-			
-			// Copy in all the old indices, if any
-			size_t j = 0;
-			if (pr_blockIndexSlotsUsed != 0) {
-				auto i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & prevBlockSizeMask;
-				do {
-					newBlockIndexEntries[j++] = pr_blockIndexEntries[i];
-					i = (i + 1) & prevBlockSizeMask;
-				} while (i != pr_blockIndexFront);
-			}
-			
-			// Update everything
-			auto header = new (newRawPtr) BlockIndexHeader;
-			header->size = pr_blockIndexSize;
-			header->front.store(numberOfFilledSlotsToExpose - 1, std::memory_order_relaxed);
-			header->entries = newBlockIndexEntries;
-			header->prev = pr_blockIndexRaw;		// we link the new block to the old one so we can free it later
-			
-			pr_blockIndexFront = j;
-			pr_blockIndexEntries = newBlockIndexEntries;
-			pr_blockIndexRaw = newRawPtr;
-			blockIndex.store(header, std::memory_order_release);
-			
-			return true;
-		}
-		
-	private:
-		std::atomic<BlockIndexHeader*> blockIndex;
-		
-		// To be used by producer only -- consumer must use the ones in referenced by blockIndex
-		size_t pr_blockIndexSlotsUsed;
-		size_t pr_blockIndexSize;
-		size_t pr_blockIndexFront;		// Next slot (not current)
-		BlockIndexEntry* pr_blockIndexEntries;
-		void* pr_blockIndexRaw;
-		
+                    newBlock->owner = this;
+#endif
+                    newBlock->ConcurrentQueue::Block::template set_all_empty<explicit_context>();
+                    if (this->tailBlock == nullptr) {
+                        newBlock->next = newBlock;
+                    }
+                    else {
+                        newBlock->next = this->tailBlock->next;
+                        this->tailBlock->next = newBlock;
+                    }
+                    this->tailBlock = newBlock;
+                    firstAllocatedBlock = firstAllocatedBlock == nullptr ? this->tailBlock : firstAllocatedBlock;
+                    
+                    ++pr_blockIndexSlotsUsed;
+                    
+                    auto& entry = blockIndex.load(std::memory_order_relaxed)->entries[pr_blockIndexFront];
+                    entry.base = currentTailIndex;
+                    entry.block = this->tailBlock;
+                    pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
+                }
+                
+                // Excellent, all allocations succeeded. Reset each block's emptiness before we fill them up, and
+                // publish the new block index front
+                auto block = firstAllocatedBlock;
+                while (true) {
+                    block->ConcurrentQueue::Block::template reset_empty<explicit_context>();
+                    if (block == this->tailBlock) {
+                        break;
+                    }
+                    block = block->next;
+                }
+                
+                MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
+                    blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
+                }
+            }
+            
+            // Enqueue, one block at a time
+            index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
+            currentTailIndex = startTailIndex;
+            auto endBlock = this->tailBlock;
+            this->tailBlock = startBlock;
+            assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
+            if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
+                this->tailBlock = firstAllocatedBlock;
+            }
+            while (true) {
+                index_t stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+                if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
+                    stopIndex = newTailIndex;
+                }
+                MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
+                    while (currentTailIndex != stopIndex) {
+                        new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
+                    }
+                }
+                else {
+                    MOODYCAMEL_TRY {
+                        while (currentTailIndex != stopIndex) {
+                            // Must use copy constructor even if move constructor is available
+                            // because we may have to revert if there's an exception.
+                            // Sorry about the horrible templated next line, but it was the only way
+                            // to disable moving *at compile time*, which is important because a type
+                            // may only define a (noexcept) move constructor, and so calls to the
+                            // cctor will not compile, even if they are in an if branch that will never
+                            // be executed
+                            new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
+                            ++currentTailIndex;
+                            ++itemFirst;
+                        }
+                    }
+                    MOODYCAMEL_CATCH (...) {
+                        // Oh dear, an exception's been thrown -- destroy the elements that
+                        // were enqueued so far and revert the entire bulk operation (we'll keep
+                        // any allocated blocks in our linked list for later, though).
+                        auto constructedStopIndex = currentTailIndex;
+                        auto lastBlockEnqueued = this->tailBlock;
+                        
+                        pr_blockIndexFront = originalBlockIndexFront;
+                        pr_blockIndexSlotsUsed = originalBlockIndexSlotsUsed;
+                        this->tailBlock = startBlock == nullptr ? firstAllocatedBlock : startBlock;
+                        
+                        if (!details::is_trivially_destructible<T>::value) {
+                            auto block = startBlock;
+                            if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
+                                block = firstAllocatedBlock;
+                            }
+                            currentTailIndex = startTailIndex;
+                            while (true) {
+                                stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+                                if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
+                                    stopIndex = constructedStopIndex;
+                                }
+                                while (currentTailIndex != stopIndex) {
+                                    (*block)[currentTailIndex++]->~T();
+                                }
+                                if (block == lastBlockEnqueued) {
+                                    break;
+                                }
+                                block = block->next;
+                            }
+                        }
+                        MOODYCAMEL_RETHROW;
+                    }
+                }
+                
+                if (this->tailBlock == endBlock) {
+                    assert(currentTailIndex == newTailIndex);
+                    break;
+                }
+                this->tailBlock = this->tailBlock->next;
+            }
+            
+            MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
+                if (firstAllocatedBlock != nullptr)
+                    blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
+            }
+            
+            this->tailIndex.store(newTailIndex, std::memory_order_release);
+            return true;
+        }
+        
+        template<typename It>
+        size_t dequeue_bulk(It& itemFirst, size_t max)
+        {
+            auto tail = this->tailIndex.load(std::memory_order_relaxed);
+            auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
+            auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
+            if (details::circular_less_than<size_t>(0, desiredCount)) {
+                desiredCount = desiredCount < max ? desiredCount : max;
+                std::atomic_thread_fence(std::memory_order_acquire);
+                
+                auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);
+                
+                tail = this->tailIndex.load(std::memory_order_acquire);
+                auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
+                if (details::circular_less_than<size_t>(0, actualCount)) {
+                    actualCount = desiredCount < actualCount ? desiredCount : actualCount;
+                    if (actualCount < desiredCount) {
+                        this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
+                    }
+                    
+                    // Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
+                    // will never exceed tail.
+                    auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
+                    
+                    // Determine which block the first element is in
+                    auto localBlockIndex = blockIndex.load(std::memory_order_acquire);
+                    auto localBlockIndexHead = localBlockIndex->front.load(std::memory_order_acquire);
+                    
+                    auto headBase = localBlockIndex->entries[localBlockIndexHead].base;
+                    auto firstBlockBaseIndex = firstIndex & ~static_cast<index_t>(BLOCK_SIZE - 1);
+                    auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(firstBlockBaseIndex - headBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
+                    auto indexIndex = (localBlockIndexHead + offset) & (localBlockIndex->size - 1);
+                    
+                    // Iterate the blocks and dequeue
+                    auto index = firstIndex;
+                    do {
+                        auto firstIndexInBlock = index;
+                        index_t endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+                        endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
+                        auto block = localBlockIndex->entries[indexIndex].block;
+                        if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
+                            while (index != endIndex) {
+                                auto& el = *((*block)[index]);
+                                *itemFirst++ = std::move(el);
+                                el.~T();
+                                ++index;
+                            }
+                        }
+                        else {
+                            MOODYCAMEL_TRY {
+                                while (index != endIndex) {
+                                    auto& el = *((*block)[index]);
+                                    *itemFirst = std::move(el);
+                                    ++itemFirst;
+                                    el.~T();
+                                    ++index;
+                                }
+                            }
+                            MOODYCAMEL_CATCH (...) {
+                                // It's too late to revert the dequeue, but we can make sure that all
+                                // the dequeued objects are properly destroyed and the block index
+                                // (and empty count) are properly updated before we propagate the exception
+                                do {
+                                    block = localBlockIndex->entries[indexIndex].block;
+                                    while (index != endIndex) {
+                                        (*block)[index++]->~T();
+                                    }
+                                    block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
+                                    indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
+                                    
+                                    firstIndexInBlock = index;
+                                    endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+                                    endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
+                                } while (index != firstIndex + actualCount);
+                                
+                                MOODYCAMEL_RETHROW;
+                            }
+                        }
+                        block->ConcurrentQueue::Block::template set_many_empty<explicit_context>(firstIndexInBlock, static_cast<size_t>(endIndex - firstIndexInBlock));
+                        indexIndex = (indexIndex + 1) & (localBlockIndex->size - 1);
+                    } while (index != firstIndex + actualCount);
+                    
+                    return actualCount;
+                }
+                else {
+                    // Wasn't anything to dequeue after all; make the effective dequeue count eventually consistent
+                    this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
+                }
+            }
+            
+            return 0;
+        }
+        
+    private:
+        struct BlockIndexEntry
+        {
+            index_t base;
+            Block* block;
+        };
+        
+        struct BlockIndexHeader
+        {
+            size_t size;
+            std::atomic<size_t> front;		// Current slot (not next, like pr_blockIndexFront)
+            BlockIndexEntry* entries;
+            void* prev;
+        };
+        
+        
+        bool new_block_index(size_t numberOfFilledSlotsToExpose)
+        {
+            auto prevBlockSizeMask = pr_blockIndexSize - 1;
+            
+            // Create the new block
+            pr_blockIndexSize <<= 1;
+            auto newRawPtr = static_cast<char*>((Traits::malloc)(sizeof(BlockIndexHeader) + std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * pr_blockIndexSize));
+            if (newRawPtr == nullptr) {
+                pr_blockIndexSize >>= 1;		// Reset to allow graceful retry
+                return false;
+            }
+            
+            auto newBlockIndexEntries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(newRawPtr + sizeof(BlockIndexHeader)));
+            
+            // Copy in all the old indices, if any
+            size_t j = 0;
+            if (pr_blockIndexSlotsUsed != 0) {
+                auto i = (pr_blockIndexFront - pr_blockIndexSlotsUsed) & prevBlockSizeMask;
+                do {
+                    newBlockIndexEntries[j++] = pr_blockIndexEntries[i];
+                    i = (i + 1) & prevBlockSizeMask;
+                } while (i != pr_blockIndexFront);
+            }
+            
+            // Update everything
+            auto header = new (newRawPtr) BlockIndexHeader;
+            header->size = pr_blockIndexSize;
+            header->front.store(numberOfFilledSlotsToExpose - 1, std::memory_order_relaxed);
+            header->entries = newBlockIndexEntries;
+            header->prev = pr_blockIndexRaw;		// we link the new block to the old one so we can free it later
+            
+            pr_blockIndexFront = j;
+            pr_blockIndexEntries = newBlockIndexEntries;
+            pr_blockIndexRaw = newRawPtr;
+            blockIndex.store(header, std::memory_order_release);
+            
+            return true;
+        }
+        
+    private:
+        std::atomic<BlockIndexHeader*> blockIndex;
+        
+        // To be used by producer only -- consumer must use the ones in referenced by blockIndex
+        size_t pr_blockIndexSlotsUsed;
+        size_t pr_blockIndexSize;
+        size_t pr_blockIndexFront;		// Next slot (not current)
+        BlockIndexEntry* pr_blockIndexEntries;
+        void* pr_blockIndexRaw;
+        
 #ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-	public:
-		ExplicitProducer* nextExplicitProducer;
-	private:
+    public:
+        ExplicitProducer* nextExplicitProducer;
+    private:
 #endif
-		
+        
 #ifdef MCDBGQ_TRACKMEM
-		friend struct MemStats;
-#endif
-	};
-	
-	
-	//////////////////////////////////
-	// Implicit queue
-	//////////////////////////////////
-	
-	struct ImplicitProducer : public ProducerBase
-	{			
-		ImplicitProducer(ConcurrentQueue* parent_) :
-			ProducerBase(parent_, false),
-			nextBlockIndexCapacity(IMPLICIT_INITIAL_INDEX_SIZE),
-			blockIndex(nullptr)
-		{
-			new_block_index();
-		}
-		
-		~ImplicitProducer()
-		{
-			// Note that since we're in the destructor we can assume that all enqueue/dequeue operations
-			// completed already; this means that all undequeued elements are placed contiguously across
-			// contiguous blocks, and that only the first and last remaining blocks can be only partially
-			// empty (all other remaining blocks must be completely full).
-			
+        friend struct MemStats;
+#endif
+    };
+    
+    
+    //////////////////////////////////
+    // Implicit queue
+    //////////////////////////////////
+    
+    struct ImplicitProducer : public ProducerBase
+    {			
+        ImplicitProducer(ConcurrentQueue* parent_) :
+            ProducerBase(parent_, false),
+            nextBlockIndexCapacity(IMPLICIT_INITIAL_INDEX_SIZE),
+            blockIndex(nullptr)
+        {
+            new_block_index();
+        }
+        
+        ~ImplicitProducer()
+        {
+            // Note that since we're in the destructor we can assume that all enqueue/dequeue operations
+            // completed already; this means that all undequeued elements are placed contiguously across
+            // contiguous blocks, and that only the first and last remaining blocks can be only partially
+            // empty (all other remaining blocks must be completely full).
+            
 #ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-			// Unregister ourselves for thread termination notification
-			if (!this->inactive.load(std::memory_order_relaxed)) {
-				details::ThreadExitNotifier::unsubscribe(&threadExitListener);
-			}
-#endif
-			
-			// Destroy all remaining elements!
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto index = this->headIndex.load(std::memory_order_relaxed);
-			Block* block = nullptr;
-			assert(index == tail || details::circular_less_than(index, tail));
-			bool forceFreeLastBlock = index != tail;		// If we enter the loop, then the last (tail) block will not be freed
-			while (index != tail) {
-				if ((index & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 || block == nullptr) {
-					if (block != nullptr) {
-						// Free the old block
-						this->parent->add_block_to_free_list(block);
-					}
-					
-					block = get_block_index_entry_for_index(index)->value.load(std::memory_order_relaxed);
-				}
-				
-				((*block)[index])->~T();
-				++index;
-			}
-			// Even if the queue is empty, there's still one block that's not on the free list
-			// (unless the head index reached the end of it, in which case the tail will be poised
-			// to create a new block).
-			if (this->tailBlock != nullptr && (forceFreeLastBlock || (tail & static_cast<index_t>(BLOCK_SIZE - 1)) != 0)) {
-				this->parent->add_block_to_free_list(this->tailBlock);
-			}
-			
-			// Destroy block index
-			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
-			if (localBlockIndex != nullptr) {
-				for (size_t i = 0; i != localBlockIndex->capacity; ++i) {
-					localBlockIndex->index[i]->~BlockIndexEntry();
-				}
-				do {
-					auto prev = localBlockIndex->prev;
-					localBlockIndex->~BlockIndexHeader();
-					(Traits::free)(localBlockIndex);
-					localBlockIndex = prev;
-				} while (localBlockIndex != nullptr);
-			}
-		}
-		
-		template<AllocationMode allocMode, typename U>
-		inline bool enqueue(U&& element)
-		{
-			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			index_t newTailIndex = 1 + currentTailIndex;
-			if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-				// We reached the end of a block, start a new one
-				auto head = this->headIndex.load(std::memory_order_relaxed);
-				assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-				if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
-					return false;
-				}
+            // Unregister ourselves for thread termination notification
+            if (!this->inactive.load(std::memory_order_relaxed)) {
+                details::ThreadExitNotifier::unsubscribe(&threadExitListener);
+            }
+#endif
+            
+            // Destroy all remaining elements!
+            auto tail = this->tailIndex.load(std::memory_order_relaxed);
+            auto index = this->headIndex.load(std::memory_order_relaxed);
+            Block* block = nullptr;
+            assert(index == tail || details::circular_less_than(index, tail));
+            bool forceFreeLastBlock = index != tail;		// If we enter the loop, then the last (tail) block will not be freed
+            while (index != tail) {
+                if ((index & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 || block == nullptr) {
+                    if (block != nullptr) {
+                        // Free the old block
+                        this->parent->add_block_to_free_list(block);
+                    }
+                    
+                    block = get_block_index_entry_for_index(index)->value.load(std::memory_order_relaxed);
+                }
+                
+                ((*block)[index])->~T();
+                ++index;
+            }
+            // Even if the queue is empty, there's still one block that's not on the free list
+            // (unless the head index reached the end of it, in which case the tail will be poised
+            // to create a new block).
+            if (this->tailBlock != nullptr && (forceFreeLastBlock || (tail & static_cast<index_t>(BLOCK_SIZE - 1)) != 0)) {
+                this->parent->add_block_to_free_list(this->tailBlock);
+            }
+            
+            // Destroy block index
+            auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
+            if (localBlockIndex != nullptr) {
+                for (size_t i = 0; i != localBlockIndex->capacity; ++i) {
+                    localBlockIndex->index[i]->~BlockIndexEntry();
+                }
+                do {
+                    auto prev = localBlockIndex->prev;
+                    localBlockIndex->~BlockIndexHeader();
+                    (Traits::free)(localBlockIndex);
+                    localBlockIndex = prev;
+                } while (localBlockIndex != nullptr);
+            }
+        }
+        
+        template<AllocationMode allocMode, typename U>
+        inline bool enqueue(U&& element)
+        {
+            index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
+            index_t newTailIndex = 1 + currentTailIndex;
+            if ((currentTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
+                // We reached the end of a block, start a new one
+                auto head = this->headIndex.load(std::memory_order_relaxed);
+                assert(!details::circular_less_than<index_t>(currentTailIndex, head));
+                if (!details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head))) {
+                    return false;
+                }
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-				debug::DebugLock lock(mutex);
-#endif
-				// Find out where we'll be inserting this block in the block index
-				BlockIndexEntry* idxEntry;
-				if (!insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) {
-					return false;
-				}
-				
-				// Get ahold of a new block
-				auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
-				if (newBlock == nullptr) {
-					rewind_block_index_tail();
-					idxEntry->value.store(nullptr, std::memory_order_relaxed);
-					return false;
-				}
+                debug::DebugLock lock(mutex);
+#endif
+                // Find out where we'll be inserting this block in the block index
+                BlockIndexEntry* idxEntry;
+                if (!insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) {
+                    return false;
+                }
+                
+                // Get ahold of a new block
+                auto newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>();
+                if (newBlock == nullptr) {
+                    rewind_block_index_tail();
+                    idxEntry->value.store(nullptr, std::memory_order_relaxed);
+                    return false;
+                }
 #ifdef MCDBGQ_TRACKMEM
-				newBlock->owner = this;
-#endif
-				newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
-
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
-					// May throw, try to insert now before we publish the fact that we have this new block
-					MOODYCAMEL_TRY {
-						new ((*newBlock)[currentTailIndex]) T(std::forward<U>(element));
-					}
-					MOODYCAMEL_CATCH (...) {
-						rewind_block_index_tail();
-						idxEntry->value.store(nullptr, std::memory_order_relaxed);
-						this->parent->add_block_to_free_list(newBlock);
-						MOODYCAMEL_RETHROW;
-					}
-				}
-				
-				// Insert the new block into the index
-				idxEntry->value.store(newBlock, std::memory_order_relaxed);
-				
-				this->tailBlock = newBlock;
-				
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
-					this->tailIndex.store(newTailIndex, std::memory_order_release);
-					return true;
-				}
-			}
-			
-			// Enqueue
-			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
-			
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
-		
-		template<typename U>
-		bool dequeue(U& element)
-		{
-			// See ExplicitProducer::dequeue for rationale and explanation
-			index_t tail = this->tailIndex.load(std::memory_order_relaxed);
-			index_t overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
-				std::atomic_thread_fence(std::memory_order_acquire);
-				
-				index_t myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				if ((details::likely)(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
-					index_t index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
-					
-					// Determine which block the element is in
-					auto entry = get_block_index_entry_for_index(index);
-					
-					// Dequeue
-					auto block = entry->value.load(std::memory_order_relaxed);
-					auto& el = *((*block)[index]);
-					
-					if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
+                newBlock->owner = this;
+#endif
+                newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
+
+                MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
+                    // May throw, try to insert now before we publish the fact that we have this new block
+                    MOODYCAMEL_TRY {
+                        new ((*newBlock)[currentTailIndex]) T(std::forward<U>(element));
+                    }
+                    MOODYCAMEL_CATCH (...) {
+                        rewind_block_index_tail();
+                        idxEntry->value.store(nullptr, std::memory_order_relaxed);
+                        this->parent->add_block_to_free_list(newBlock);
+                        MOODYCAMEL_RETHROW;
+                    }
+                }
+                
+                // Insert the new block into the index
+                idxEntry->value.store(newBlock, std::memory_order_relaxed);
+                
+                this->tailBlock = newBlock;
+                
+                MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
+                    this->tailIndex.store(newTailIndex, std::memory_order_release);
+                    return true;
+                }
+            }
+            
+            // Enqueue
+            new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
+            
+            this->tailIndex.store(newTailIndex, std::memory_order_release);
+            return true;
+        }
+        
+        template<typename U>
+        bool dequeue(U& element)
+        {
+            // See ExplicitProducer::dequeue for rationale and explanation
+            index_t tail = this->tailIndex.load(std::memory_order_relaxed);
+            index_t overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
+            if (details::circular_less_than<index_t>(this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit, tail)) {
+                std::atomic_thread_fence(std::memory_order_acquire);
+                
+                index_t myDequeueCount = this->dequeueOptimisticCount.fetch_add(1, std::memory_order_relaxed);
+                tail = this->tailIndex.load(std::memory_order_acquire);
+                if ((details::likely)(details::circular_less_than<index_t>(myDequeueCount - overcommit, tail))) {
+                    index_t index = this->headIndex.fetch_add(1, std::memory_order_acq_rel);
+                    
+                    // Determine which block the element is in
+                    auto entry = get_block_index_entry_for_index(index);
+                    
+                    // Dequeue
+                    auto block = entry->value.load(std::memory_order_relaxed);
+                    auto& el = *((*block)[index]);
+                    
+                    if (!MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, element = std::move(el))) {
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-						// Note: Acquiring the mutex with every dequeue instead of only when a block
-						// is released is very sub-optimal, but it is, after all, purely debug code.
-						debug::DebugLock lock(producer->mutex);
-#endif
-						struct Guard {
-							Block* block;
-							index_t index;
-							BlockIndexEntry* entry;
-							ConcurrentQueue* parent;
-							
-							~Guard()
-							{
-								(*block)[index]->~T();
-								if (block->ConcurrentQueue::Block::template set_empty<implicit_context>(index)) {
-									entry->value.store(nullptr, std::memory_order_relaxed);
-									parent->add_block_to_free_list(block);
-								}
-							}
-						} guard = { block, index, entry, this->parent };
-
-						element = std::move(el); // NOLINT
-					}
-					else {
-						element = std::move(el); // NOLINT
-						el.~T(); // NOLINT
-
-						if (block->ConcurrentQueue::Block::template set_empty<implicit_context>(index)) {
-							{
+                        // Note: Acquiring the mutex with every dequeue instead of only when a block
+                        // is released is very sub-optimal, but it is, after all, purely debug code.
+                        debug::DebugLock lock(producer->mutex);
+#endif
+                        struct Guard {
+                            Block* block;
+                            index_t index;
+                            BlockIndexEntry* entry;
+                            ConcurrentQueue* parent;
+                            
+                            ~Guard()
+                            {
+                                (*block)[index]->~T();
+                                if (block->ConcurrentQueue::Block::template set_empty<implicit_context>(index)) {
+                                    entry->value.store(nullptr, std::memory_order_relaxed);
+                                    parent->add_block_to_free_list(block);
+                                }
+                            }
+                        } guard = { block, index, entry, this->parent };
+
+                        element = std::move(el); // NOLINT
+                    }
+                    else {
+                        element = std::move(el); // NOLINT
+                        el.~T(); // NOLINT
+
+                        if (block->ConcurrentQueue::Block::template set_empty<implicit_context>(index)) {
+                            {
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-								debug::DebugLock lock(mutex);
-#endif
-								// Add the block back into the global free pool (and remove from block index)
-								entry->value.store(nullptr, std::memory_order_relaxed);
-							}
-							this->parent->add_block_to_free_list(block);		// releases the above store
-						}
-					}
-					
-					return true;
-				}
-				else {
-					this->dequeueOvercommit.fetch_add(1, std::memory_order_release);
-				}
-			}
-		
-			return false;
-		}
-		
+                                debug::DebugLock lock(mutex);
+#endif
+                                // Add the block back into the global free pool (and remove from block index)
+                                entry->value.store(nullptr, std::memory_order_relaxed);
+                            }
+                            this->parent->add_block_to_free_list(block);		// releases the above store
+                        }
+                    }
+                    
+                    return true;
+                }
+                else {
+                    this->dequeueOvercommit.fetch_add(1, std::memory_order_release);
+                }
+            }
+        
+            return false;
+        }
+        
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable: 4706)  // assignment within conditional expression
 #endif
-		template<AllocationMode allocMode, typename It>
-		bool enqueue_bulk(It itemFirst, size_t count)
-		{
-			// First, we need to make sure we have enough room to enqueue all of the elements;
-			// this means pre-allocating blocks and putting them in the block index (but only if
-			// all the allocations succeeded).
-			
-			// Note that the tailBlock we start off with may not be owned by us any more;
-			// this happens if it was filled up exactly to the top (setting tailIndex to
-			// the first index of the next block which is not yet allocated), then dequeued
-			// completely (putting it on the free list) before we enqueue again.
-			
-			index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
-			auto startBlock = this->tailBlock;
-			Block* firstAllocatedBlock = nullptr;
-			auto endBlock = this->tailBlock;
-			
-			// Figure out how many blocks we'll need to allocate, and do so
-			size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
-			index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-			if (blockBaseDiff > 0) {
+        template<AllocationMode allocMode, typename It>
+        bool enqueue_bulk(It itemFirst, size_t count)
+        {
+            // First, we need to make sure we have enough room to enqueue all of the elements;
+            // this means pre-allocating blocks and putting them in the block index (but only if
+            // all the allocations succeeded).
+            
+            // Note that the tailBlock we start off with may not be owned by us any more;
+            // this happens if it was filled up exactly to the top (setting tailIndex to
+            // the first index of the next block which is not yet allocated), then dequeued
+            // completely (putting it on the free list) before we enqueue again.
+            
+            index_t startTailIndex = this->tailIndex.load(std::memory_order_relaxed);
+            auto startBlock = this->tailBlock;
+            Block* firstAllocatedBlock = nullptr;
+            auto endBlock = this->tailBlock;
+            
+            // Figure out how many blocks we'll need to allocate, and do so
+            size_t blockBaseDiff = ((startTailIndex + count - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1)) - ((startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1));
+            index_t currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
+            if (blockBaseDiff > 0) {
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-				debug::DebugLock lock(mutex);
-#endif
-				do {
-					blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
-					currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-					
-					// Find out where we'll be inserting this block in the block index
-					BlockIndexEntry* idxEntry = nullptr;  // initialization here unnecessary but compiler can't always tell
-					Block* newBlock;
-					bool indexInserted = false;
-					auto head = this->headIndex.load(std::memory_order_relaxed);
-					assert(!details::circular_less_than<index_t>(currentTailIndex, head));
-					bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
-
-					if (full || !(indexInserted = insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) || (newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>()) == nullptr) {
-						// Index allocation or block allocation failed; revert any other allocations
-						// and index insertions done so far for this operation
-						if (indexInserted) {
-							rewind_block_index_tail();
-							idxEntry->value.store(nullptr, std::memory_order_relaxed);
-						}
-						currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-						for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
-							currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-							idxEntry = get_block_index_entry_for_index(currentTailIndex);
-							idxEntry->value.store(nullptr, std::memory_order_relaxed);
-							rewind_block_index_tail();
-						}
-						this->parent->add_blocks_to_free_list(firstAllocatedBlock);
-						this->tailBlock = startBlock;
-						
-						return false;
-					}
-					
+                debug::DebugLock lock(mutex);
+#endif
+                do {
+                    blockBaseDiff -= static_cast<index_t>(BLOCK_SIZE);
+                    currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
+                    
+                    // Find out where we'll be inserting this block in the block index
+                    BlockIndexEntry* idxEntry = nullptr;  // initialization here unnecessary but compiler can't always tell
+                    Block* newBlock;
+                    bool indexInserted = false;
+                    auto head = this->headIndex.load(std::memory_order_relaxed);
+                    assert(!details::circular_less_than<index_t>(currentTailIndex, head));
+                    bool full = !details::circular_less_than<index_t>(head, currentTailIndex + BLOCK_SIZE) || (MAX_SUBQUEUE_SIZE != details::const_numeric_max<size_t>::value && (MAX_SUBQUEUE_SIZE == 0 || MAX_SUBQUEUE_SIZE - BLOCK_SIZE < currentTailIndex - head));
+
+                    if (full || !(indexInserted = insert_block_index_entry<allocMode>(idxEntry, currentTailIndex)) || (newBlock = this->parent->ConcurrentQueue::template requisition_block<allocMode>()) == nullptr) {
+                        // Index allocation or block allocation failed; revert any other allocations
+                        // and index insertions done so far for this operation
+                        if (indexInserted) {
+                            rewind_block_index_tail();
+                            idxEntry->value.store(nullptr, std::memory_order_relaxed);
+                        }
+                        currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
+                        for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
+                            currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
+                            idxEntry = get_block_index_entry_for_index(currentTailIndex);
+                            idxEntry->value.store(nullptr, std::memory_order_relaxed);
+                            rewind_block_index_tail();
+                        }
+                        this->parent->add_blocks_to_free_list(firstAllocatedBlock);
+                        this->tailBlock = startBlock;
+                        
+                        return false;
+                    }
+                    
 #ifdef MCDBGQ_TRACKMEM
-					newBlock->owner = this;
-#endif
-					newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
-					newBlock->next = nullptr;
-					
-					// Insert the new block into the index
-					idxEntry->value.store(newBlock, std::memory_order_relaxed);
-					
-					// Store the chain of blocks so that we can undo if later allocations fail,
-					// and so that we can find the blocks when we do the actual enqueueing
-					if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr) {
-						assert(this->tailBlock != nullptr);
-						this->tailBlock->next = newBlock;
-					}
-					this->tailBlock = newBlock;
-					endBlock = newBlock;
-					firstAllocatedBlock = firstAllocatedBlock == nullptr ? newBlock : firstAllocatedBlock;
-				} while (blockBaseDiff > 0);
-			}
-			
-			// Enqueue, one block at a time
-			index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
-			currentTailIndex = startTailIndex;
-			this->tailBlock = startBlock;
-			assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
-			if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
-				this->tailBlock = firstAllocatedBlock;
-			}
-			while (true) {
-				index_t stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
-					stopIndex = newTailIndex;
-				}
-				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
-					while (currentTailIndex != stopIndex) {
-						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
-					}
-				}
-				else {
-					MOODYCAMEL_TRY {
-						while (currentTailIndex != stopIndex) {
-							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
-							++currentTailIndex;
-							++itemFirst;
-						}
-					}
-					MOODYCAMEL_CATCH (...) {
-						auto constructedStopIndex = currentTailIndex;
-						auto lastBlockEnqueued = this->tailBlock;
-						
-						if (!details::is_trivially_destructible<T>::value) {
-							auto block = startBlock;
-							if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
-								block = firstAllocatedBlock;
-							}
-							currentTailIndex = startTailIndex;
-							while (true) {
-								stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-								if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
-									stopIndex = constructedStopIndex;
-								}
-								while (currentTailIndex != stopIndex) {
-									(*block)[currentTailIndex++]->~T();
-								}
-								if (block == lastBlockEnqueued) {
-									break;
-								}
-								block = block->next;
-							}
-						}
-						
-						currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
-						for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
-							currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
-							auto idxEntry = get_block_index_entry_for_index(currentTailIndex);
-							idxEntry->value.store(nullptr, std::memory_order_relaxed);
-							rewind_block_index_tail();
-						}
-						this->parent->add_blocks_to_free_list(firstAllocatedBlock);
-						this->tailBlock = startBlock;
-						MOODYCAMEL_RETHROW;
-					}
-				}
-				
-				if (this->tailBlock == endBlock) {
-					assert(currentTailIndex == newTailIndex);
-					break;
-				}
-				this->tailBlock = this->tailBlock->next;
-			}
-			this->tailIndex.store(newTailIndex, std::memory_order_release);
-			return true;
-		}
+                    newBlock->owner = this;
+#endif
+                    newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
+                    newBlock->next = nullptr;
+                    
+                    // Insert the new block into the index
+                    idxEntry->value.store(newBlock, std::memory_order_relaxed);
+                    
+                    // Store the chain of blocks so that we can undo if later allocations fail,
+                    // and so that we can find the blocks when we do the actual enqueueing
+                    if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr) {
+                        assert(this->tailBlock != nullptr);
+                        this->tailBlock->next = newBlock;
+                    }
+                    this->tailBlock = newBlock;
+                    endBlock = newBlock;
+                    firstAllocatedBlock = firstAllocatedBlock == nullptr ? newBlock : firstAllocatedBlock;
+                } while (blockBaseDiff > 0);
+            }
+            
+            // Enqueue, one block at a time
+            index_t newTailIndex = startTailIndex + static_cast<index_t>(count);
+            currentTailIndex = startTailIndex;
+            this->tailBlock = startBlock;
+            assert((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) != 0 || firstAllocatedBlock != nullptr || count == 0);
+            if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0 && firstAllocatedBlock != nullptr) {
+                this->tailBlock = firstAllocatedBlock;
+            }
+            while (true) {
+                index_t stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+                if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
+                    stopIndex = newTailIndex;
+                }
+                MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
+                    while (currentTailIndex != stopIndex) {
+                        new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
+                    }
+                }
+                else {
+                    MOODYCAMEL_TRY {
+                        while (currentTailIndex != stopIndex) {
+                            new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
+                            ++currentTailIndex;
+                            ++itemFirst;
+                        }
+                    }
+                    MOODYCAMEL_CATCH (...) {
+                        auto constructedStopIndex = currentTailIndex;
+                        auto lastBlockEnqueued = this->tailBlock;
+                        
+                        if (!details::is_trivially_destructible<T>::value) {
+                            auto block = startBlock;
+                            if ((startTailIndex & static_cast<index_t>(BLOCK_SIZE - 1)) == 0) {
+                                block = firstAllocatedBlock;
+                            }
+                            currentTailIndex = startTailIndex;
+                            while (true) {
+                                stopIndex = (currentTailIndex & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+                                if (details::circular_less_than<index_t>(constructedStopIndex, stopIndex)) {
+                                    stopIndex = constructedStopIndex;
+                                }
+                                while (currentTailIndex != stopIndex) {
+                                    (*block)[currentTailIndex++]->~T();
+                                }
+                                if (block == lastBlockEnqueued) {
+                                    break;
+                                }
+                                block = block->next;
+                            }
+                        }
+                        
+                        currentTailIndex = (startTailIndex - 1) & ~static_cast<index_t>(BLOCK_SIZE - 1);
+                        for (auto block = firstAllocatedBlock; block != nullptr; block = block->next) {
+                            currentTailIndex += static_cast<index_t>(BLOCK_SIZE);
+                            auto idxEntry = get_block_index_entry_for_index(currentTailIndex);
+                            idxEntry->value.store(nullptr, std::memory_order_relaxed);
+                            rewind_block_index_tail();
+                        }
+                        this->parent->add_blocks_to_free_list(firstAllocatedBlock);
+                        this->tailBlock = startBlock;
+                        MOODYCAMEL_RETHROW;
+                    }
+                }
+                
+                if (this->tailBlock == endBlock) {
+                    assert(currentTailIndex == newTailIndex);
+                    break;
+                }
+                this->tailBlock = this->tailBlock->next;
+            }
+            this->tailIndex.store(newTailIndex, std::memory_order_release);
+            return true;
+        }
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
-		
-		template<typename It>
-		size_t dequeue_bulk(It& itemFirst, size_t max)
-		{
-			auto tail = this->tailIndex.load(std::memory_order_relaxed);
-			auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
-			auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
-			if (details::circular_less_than<size_t>(0, desiredCount)) {
-				desiredCount = desiredCount < max ? desiredCount : max;
-				std::atomic_thread_fence(std::memory_order_acquire);
-				
-				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);
-				
-				tail = this->tailIndex.load(std::memory_order_acquire);
-				auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
-				if (details::circular_less_than<size_t>(0, actualCount)) {
-					actualCount = desiredCount < actualCount ? desiredCount : actualCount;
-					if (actualCount < desiredCount) {
-						this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
-					}
-					
-					// Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
-					// will never exceed tail.
-					auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
-					
-					// Iterate the blocks and dequeue
-					auto index = firstIndex;
-					BlockIndexHeader* localBlockIndex;
-					auto indexIndex = get_block_index_index_for_index(index, localBlockIndex);
-					do {
-						auto blockStartIndex = index;
-						index_t endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-						endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-						
-						auto entry = localBlockIndex->index[indexIndex];
-						auto block = entry->value.load(std::memory_order_relaxed);
-						if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
-							while (index != endIndex) {
-								auto& el = *((*block)[index]);
-								*itemFirst++ = std::move(el);
-								el.~T();
-								++index;
-							}
-						}
-						else {
-							MOODYCAMEL_TRY {
-								while (index != endIndex) {
-									auto& el = *((*block)[index]);
-									*itemFirst = std::move(el);
-									++itemFirst;
-									el.~T();
-									++index;
-								}
-							}
-							MOODYCAMEL_CATCH (...) {
-								do {
-									entry = localBlockIndex->index[indexIndex];
-									block = entry->value.load(std::memory_order_relaxed);
-									while (index != endIndex) {
-										(*block)[index++]->~T();
-									}
-									
-									if (block->ConcurrentQueue::Block::template set_many_empty<implicit_context>(blockStartIndex, static_cast<size_t>(endIndex - blockStartIndex))) {
+        
+        template<typename It>
+        size_t dequeue_bulk(It& itemFirst, size_t max)
+        {
+            auto tail = this->tailIndex.load(std::memory_order_relaxed);
+            auto overcommit = this->dequeueOvercommit.load(std::memory_order_relaxed);
+            auto desiredCount = static_cast<size_t>(tail - (this->dequeueOptimisticCount.load(std::memory_order_relaxed) - overcommit));
+            if (details::circular_less_than<size_t>(0, desiredCount)) {
+                desiredCount = desiredCount < max ? desiredCount : max;
+                std::atomic_thread_fence(std::memory_order_acquire);
+                
+                auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);
+                
+                tail = this->tailIndex.load(std::memory_order_acquire);
+                auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
+                if (details::circular_less_than<size_t>(0, actualCount)) {
+                    actualCount = desiredCount < actualCount ? desiredCount : actualCount;
+                    if (actualCount < desiredCount) {
+                        this->dequeueOvercommit.fetch_add(desiredCount - actualCount, std::memory_order_release);
+                    }
+                    
+                    // Get the first index. Note that since there's guaranteed to be at least actualCount elements, this
+                    // will never exceed tail.
+                    auto firstIndex = this->headIndex.fetch_add(actualCount, std::memory_order_acq_rel);
+                    
+                    // Iterate the blocks and dequeue
+                    auto index = firstIndex;
+                    BlockIndexHeader* localBlockIndex;
+                    auto indexIndex = get_block_index_index_for_index(index, localBlockIndex);
+                    do {
+                        auto blockStartIndex = index;
+                        index_t endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+                        endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
+                        
+                        auto entry = localBlockIndex->index[indexIndex];
+                        auto block = entry->value.load(std::memory_order_relaxed);
+                        if (MOODYCAMEL_NOEXCEPT_ASSIGN(T, T&&, details::deref_noexcept(itemFirst) = std::move((*(*block)[index])))) {
+                            while (index != endIndex) {
+                                auto& el = *((*block)[index]);
+                                *itemFirst++ = std::move(el);
+                                el.~T();
+                                ++index;
+                            }
+                        }
+                        else {
+                            MOODYCAMEL_TRY {
+                                while (index != endIndex) {
+                                    auto& el = *((*block)[index]);
+                                    *itemFirst = std::move(el);
+                                    ++itemFirst;
+                                    el.~T();
+                                    ++index;
+                                }
+                            }
+                            MOODYCAMEL_CATCH (...) {
+                                do {
+                                    entry = localBlockIndex->index[indexIndex];
+                                    block = entry->value.load(std::memory_order_relaxed);
+                                    while (index != endIndex) {
+                                        (*block)[index++]->~T();
+                                    }
+                                    
+                                    if (block->ConcurrentQueue::Block::template set_many_empty<implicit_context>(blockStartIndex, static_cast<size_t>(endIndex - blockStartIndex))) {
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-										debug::DebugLock lock(mutex);
-#endif
-										entry->value.store(nullptr, std::memory_order_relaxed);
-										this->parent->add_block_to_free_list(block);
-									}
-									indexIndex = (indexIndex + 1) & (localBlockIndex->capacity - 1);
-									
-									blockStartIndex = index;
-									endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
-									endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
-								} while (index != firstIndex + actualCount);
-								
-								MOODYCAMEL_RETHROW;
-							}
-						}
-						if (block->ConcurrentQueue::Block::template set_many_empty<implicit_context>(blockStartIndex, static_cast<size_t>(endIndex - blockStartIndex))) {
-							{
+                                        debug::DebugLock lock(mutex);
+#endif
+                                        entry->value.store(nullptr, std::memory_order_relaxed);
+                                        this->parent->add_block_to_free_list(block);
+                                    }
+                                    indexIndex = (indexIndex + 1) & (localBlockIndex->capacity - 1);
+                                    
+                                    blockStartIndex = index;
+                                    endIndex = (index & ~static_cast<index_t>(BLOCK_SIZE - 1)) + static_cast<index_t>(BLOCK_SIZE);
+                                    endIndex = details::circular_less_than<index_t>(firstIndex + static_cast<index_t>(actualCount), endIndex) ? firstIndex + static_cast<index_t>(actualCount) : endIndex;
+                                } while (index != firstIndex + actualCount);
+                                
+                                MOODYCAMEL_RETHROW;
+                            }
+                        }
+                        if (block->ConcurrentQueue::Block::template set_many_empty<implicit_context>(blockStartIndex, static_cast<size_t>(endIndex - blockStartIndex))) {
+                            {
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-								debug::DebugLock lock(mutex);
-#endif
-								// Note that the set_many_empty above did a release, meaning that anybody who acquires the block
-								// we're about to free can use it safely since our writes (and reads!) will have happened-before then.
-								entry->value.store(nullptr, std::memory_order_relaxed);
-							}
-							this->parent->add_block_to_free_list(block);		// releases the above store
-						}
-						indexIndex = (indexIndex + 1) & (localBlockIndex->capacity - 1);
-					} while (index != firstIndex + actualCount);
-					
-					return actualCount;
-				}
-				else {
-					this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
-				}
-			}
-			
-			return 0;
-		}
-		
-	private:
-		// The block size must be > 1, so any number with the low bit set is an invalid block base index
-		static const index_t INVALID_BLOCK_BASE = 1;
-		
-		struct BlockIndexEntry
-		{
-			std::atomic<index_t> key;
-			std::atomic<Block*> value;
-		};
-		
-		struct BlockIndexHeader
-		{
-			size_t capacity;
-			std::atomic<size_t> tail;
-			BlockIndexEntry* entries;
-			BlockIndexEntry** index;
-			BlockIndexHeader* prev;
-		};
-		
-		template<AllocationMode allocMode>
-		inline bool insert_block_index_entry(BlockIndexEntry*& idxEntry, index_t blockStartIndex)
-		{
-			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);		// We're the only writer thread, relaxed is OK
-			if (localBlockIndex == nullptr) {
-				return false;  // this can happen if new_block_index failed in the constructor
-			}
-			size_t newTail = (localBlockIndex->tail.load(std::memory_order_relaxed) + 1) & (localBlockIndex->capacity - 1);
-			idxEntry = localBlockIndex->index[newTail];
-			if (idxEntry->key.load(std::memory_order_relaxed) == INVALID_BLOCK_BASE ||
-				idxEntry->value.load(std::memory_order_relaxed) == nullptr) {
-				
-				idxEntry->key.store(blockStartIndex, std::memory_order_relaxed);
-				localBlockIndex->tail.store(newTail, std::memory_order_release);
-				return true;
-			}
-			
-			// No room in the old block index, try to allocate another one!
-			MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
-				return false;
-			}
-			else if (!new_block_index()) {
-				return false;
-			}
-			else {
-				localBlockIndex = blockIndex.load(std::memory_order_relaxed);
-				newTail = (localBlockIndex->tail.load(std::memory_order_relaxed) + 1) & (localBlockIndex->capacity - 1);
-				idxEntry = localBlockIndex->index[newTail];
-				assert(idxEntry->key.load(std::memory_order_relaxed) == INVALID_BLOCK_BASE);
-				idxEntry->key.store(blockStartIndex, std::memory_order_relaxed);
-				localBlockIndex->tail.store(newTail, std::memory_order_release);
-				return true;
-			}
-		}
-		
-		inline void rewind_block_index_tail()
-		{
-			auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
-			localBlockIndex->tail.store((localBlockIndex->tail.load(std::memory_order_relaxed) - 1) & (localBlockIndex->capacity - 1), std::memory_order_relaxed);
-		}
-		
-		inline BlockIndexEntry* get_block_index_entry_for_index(index_t index) const
-		{
-			BlockIndexHeader* localBlockIndex;
-			auto idx = get_block_index_index_for_index(index, localBlockIndex);
-			return localBlockIndex->index[idx];
-		}
-		
-		inline size_t get_block_index_index_for_index(index_t index, BlockIndexHeader*& localBlockIndex) const
-		{
+                                debug::DebugLock lock(mutex);
+#endif
+                                // Note that the set_many_empty above did a release, meaning that anybody who acquires the block
+                                // we're about to free can use it safely since our writes (and reads!) will have happened-before then.
+                                entry->value.store(nullptr, std::memory_order_relaxed);
+                            }
+                            this->parent->add_block_to_free_list(block);		// releases the above store
+                        }
+                        indexIndex = (indexIndex + 1) & (localBlockIndex->capacity - 1);
+                    } while (index != firstIndex + actualCount);
+                    
+                    return actualCount;
+                }
+                else {
+                    this->dequeueOvercommit.fetch_add(desiredCount, std::memory_order_release);
+                }
+            }
+            
+            return 0;
+        }
+        
+    private:
+        // The block size must be > 1, so any number with the low bit set is an invalid block base index
+        static const index_t INVALID_BLOCK_BASE = 1;
+        
+        struct BlockIndexEntry
+        {
+            std::atomic<index_t> key;
+            std::atomic<Block*> value;
+        };
+        
+        struct BlockIndexHeader
+        {
+            size_t capacity;
+            std::atomic<size_t> tail;
+            BlockIndexEntry* entries;
+            BlockIndexEntry** index;
+            BlockIndexHeader* prev;
+        };
+        
+        template<AllocationMode allocMode>
+        inline bool insert_block_index_entry(BlockIndexEntry*& idxEntry, index_t blockStartIndex)
+        {
+            auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);		// We're the only writer thread, relaxed is OK
+            if (localBlockIndex == nullptr) {
+                return false;  // this can happen if new_block_index failed in the constructor
+            }
+            size_t newTail = (localBlockIndex->tail.load(std::memory_order_relaxed) + 1) & (localBlockIndex->capacity - 1);
+            idxEntry = localBlockIndex->index[newTail];
+            if (idxEntry->key.load(std::memory_order_relaxed) == INVALID_BLOCK_BASE ||
+                idxEntry->value.load(std::memory_order_relaxed) == nullptr) {
+                
+                idxEntry->key.store(blockStartIndex, std::memory_order_relaxed);
+                localBlockIndex->tail.store(newTail, std::memory_order_release);
+                return true;
+            }
+            
+            // No room in the old block index, try to allocate another one!
+            MOODYCAMEL_CONSTEXPR_IF (allocMode == CannotAlloc) {
+                return false;
+            }
+            else if (!new_block_index()) {
+                return false;
+            }
+            else {
+                localBlockIndex = blockIndex.load(std::memory_order_relaxed);
+                newTail = (localBlockIndex->tail.load(std::memory_order_relaxed) + 1) & (localBlockIndex->capacity - 1);
+                idxEntry = localBlockIndex->index[newTail];
+                assert(idxEntry->key.load(std::memory_order_relaxed) == INVALID_BLOCK_BASE);
+                idxEntry->key.store(blockStartIndex, std::memory_order_relaxed);
+                localBlockIndex->tail.store(newTail, std::memory_order_release);
+                return true;
+            }
+        }
+        
+        inline void rewind_block_index_tail()
+        {
+            auto localBlockIndex = blockIndex.load(std::memory_order_relaxed);
+            localBlockIndex->tail.store((localBlockIndex->tail.load(std::memory_order_relaxed) - 1) & (localBlockIndex->capacity - 1), std::memory_order_relaxed);
+        }
+        
+        inline BlockIndexEntry* get_block_index_entry_for_index(index_t index) const
+        {
+            BlockIndexHeader* localBlockIndex;
+            auto idx = get_block_index_index_for_index(index, localBlockIndex);
+            return localBlockIndex->index[idx];
+        }
+        
+        inline size_t get_block_index_index_for_index(index_t index, BlockIndexHeader*& localBlockIndex) const
+        {
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-			debug::DebugLock lock(mutex);
-#endif
-			index &= ~static_cast<index_t>(BLOCK_SIZE - 1);
-			localBlockIndex = blockIndex.load(std::memory_order_acquire);
-			auto tail = localBlockIndex->tail.load(std::memory_order_acquire);
-			auto tailBase = localBlockIndex->index[tail]->key.load(std::memory_order_relaxed);
-			assert(tailBase != INVALID_BLOCK_BASE);
-			// Note: Must use division instead of shift because the index may wrap around, causing a negative
-			// offset, whose negativity we want to preserve
-			auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(index - tailBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
-			size_t idx = (tail + offset) & (localBlockIndex->capacity - 1);
-			assert(localBlockIndex->index[idx]->key.load(std::memory_order_relaxed) == index && localBlockIndex->index[idx]->value.load(std::memory_order_relaxed) != nullptr);
-			return idx;
-		}
-		
-		bool new_block_index()
-		{
-			auto prev = blockIndex.load(std::memory_order_relaxed);
-			size_t prevCapacity = prev == nullptr ? 0 : prev->capacity;
-			auto entryCount = prev == nullptr ? nextBlockIndexCapacity : prevCapacity;
-			auto raw = static_cast<char*>((Traits::malloc)(
-				sizeof(BlockIndexHeader) +
-				std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * entryCount +
-				std::alignment_of<BlockIndexEntry*>::value - 1 + sizeof(BlockIndexEntry*) * nextBlockIndexCapacity));
-			if (raw == nullptr) {
-				return false;
-			}
-			
-			auto header = new (raw) BlockIndexHeader;
-			auto entries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(raw + sizeof(BlockIndexHeader)));
-			auto index = reinterpret_cast<BlockIndexEntry**>(details::align_for<BlockIndexEntry*>(reinterpret_cast<char*>(entries) + sizeof(BlockIndexEntry) * entryCount));
-			if (prev != nullptr) {
-				auto prevTail = prev->tail.load(std::memory_order_relaxed);
-				auto prevPos = prevTail;
-				size_t i = 0;
-				do {
-					prevPos = (prevPos + 1) & (prev->capacity - 1);
-					index[i++] = prev->index[prevPos];
-				} while (prevPos != prevTail);
-				assert(i == prevCapacity);
-			}
-			for (size_t i = 0; i != entryCount; ++i) {
-				new (entries + i) BlockIndexEntry;
-				entries[i].key.store(INVALID_BLOCK_BASE, std::memory_order_relaxed);
-				index[prevCapacity + i] = entries + i;
-			}
-			header->prev = prev;
-			header->entries = entries;
-			header->index = index;
-			header->capacity = nextBlockIndexCapacity;
-			header->tail.store((prevCapacity - 1) & (nextBlockIndexCapacity - 1), std::memory_order_relaxed);
-			
-			blockIndex.store(header, std::memory_order_release);
-			
-			nextBlockIndexCapacity <<= 1;
-			
-			return true;
-		}
-		
-	private:
-		size_t nextBlockIndexCapacity;
-		std::atomic<BlockIndexHeader*> blockIndex;
+            debug::DebugLock lock(mutex);
+#endif
+            index &= ~static_cast<index_t>(BLOCK_SIZE - 1);
+            localBlockIndex = blockIndex.load(std::memory_order_acquire);
+            auto tail = localBlockIndex->tail.load(std::memory_order_acquire);
+            auto tailBase = localBlockIndex->index[tail]->key.load(std::memory_order_relaxed);
+            assert(tailBase != INVALID_BLOCK_BASE);
+            // Note: Must use division instead of shift because the index may wrap around, causing a negative
+            // offset, whose negativity we want to preserve
+            auto offset = static_cast<size_t>(static_cast<typename std::make_signed<index_t>::type>(index - tailBase) / static_cast<typename std::make_signed<index_t>::type>(BLOCK_SIZE));
+            size_t idx = (tail + offset) & (localBlockIndex->capacity - 1);
+            assert(localBlockIndex->index[idx]->key.load(std::memory_order_relaxed) == index && localBlockIndex->index[idx]->value.load(std::memory_order_relaxed) != nullptr);
+            return idx;
+        }
+        
+        bool new_block_index()
+        {
+            auto prev = blockIndex.load(std::memory_order_relaxed);
+            size_t prevCapacity = prev == nullptr ? 0 : prev->capacity;
+            auto entryCount = prev == nullptr ? nextBlockIndexCapacity : prevCapacity;
+            auto raw = static_cast<char*>((Traits::malloc)(
+                sizeof(BlockIndexHeader) +
+                std::alignment_of<BlockIndexEntry>::value - 1 + sizeof(BlockIndexEntry) * entryCount +
+                std::alignment_of<BlockIndexEntry*>::value - 1 + sizeof(BlockIndexEntry*) * nextBlockIndexCapacity));
+            if (raw == nullptr) {
+                return false;
+            }
+            
+            auto header = new (raw) BlockIndexHeader;
+            auto entries = reinterpret_cast<BlockIndexEntry*>(details::align_for<BlockIndexEntry>(raw + sizeof(BlockIndexHeader)));
+            auto index = reinterpret_cast<BlockIndexEntry**>(details::align_for<BlockIndexEntry*>(reinterpret_cast<char*>(entries) + sizeof(BlockIndexEntry) * entryCount));
+            if (prev != nullptr) {
+                auto prevTail = prev->tail.load(std::memory_order_relaxed);
+                auto prevPos = prevTail;
+                size_t i = 0;
+                do {
+                    prevPos = (prevPos + 1) & (prev->capacity - 1);
+                    index[i++] = prev->index[prevPos];
+                } while (prevPos != prevTail);
+                assert(i == prevCapacity);
+            }
+            for (size_t i = 0; i != entryCount; ++i) {
+                new (entries + i) BlockIndexEntry;
+                entries[i].key.store(INVALID_BLOCK_BASE, std::memory_order_relaxed);
+                index[prevCapacity + i] = entries + i;
+            }
+            header->prev = prev;
+            header->entries = entries;
+            header->index = index;
+            header->capacity = nextBlockIndexCapacity;
+            header->tail.store((prevCapacity - 1) & (nextBlockIndexCapacity - 1), std::memory_order_relaxed);
+            
+            blockIndex.store(header, std::memory_order_release);
+            
+            nextBlockIndexCapacity <<= 1;
+            
+            return true;
+        }
+        
+    private:
+        size_t nextBlockIndexCapacity;
+        std::atomic<BlockIndexHeader*> blockIndex;
 
 #ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-	public:
-		details::ThreadExitListener threadExitListener;
-	private:
+    public:
+        details::ThreadExitListener threadExitListener;
+    private:
 #endif
-		
+        
 #ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-	public:
-		ImplicitProducer* nextImplicitProducer;
-	private:
+    public:
+        ImplicitProducer* nextImplicitProducer;
+    private:
 #endif
 
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODBLOCKINDEX
-		mutable debug::DebugMutex mutex;
+        mutable debug::DebugMutex mutex;
 #endif
 #ifdef MCDBGQ_TRACKMEM
-		friend struct MemStats;
-#endif
-	};
-	
-	
-	//////////////////////////////////
-	// Block pool manipulation
-	//////////////////////////////////
-	
-	void populate_initial_block_list(size_t blockCount)
-	{
-		initialBlockPoolSize = blockCount;
-		if (initialBlockPoolSize == 0) {
-			initialBlockPool = nullptr;
-			return;
-		}
-		
-		initialBlockPool = create_array<Block>(blockCount);
-		if (initialBlockPool == nullptr) {
-			initialBlockPoolSize = 0;
-		}
-		for (size_t i = 0; i < initialBlockPoolSize; ++i) {
-			initialBlockPool[i].dynamicallyAllocated = false;
-		}
-	}
-	
-	inline Block* try_get_block_from_initial_pool()
-	{
-		if (initialBlockPoolIndex.load(std::memory_order_relaxed) >= initialBlockPoolSize) {
-			return nullptr;
-		}
-		
-		auto index = initialBlockPoolIndex.fetch_add(1, std::memory_order_relaxed);
-		
-		return index < initialBlockPoolSize ? (initialBlockPool + index) : nullptr;
-	}
-	
-	inline void add_block_to_free_list(Block* block)
-	{
+        friend struct MemStats;
+#endif
+    };
+    
+    
+    //////////////////////////////////
+    // Block pool manipulation
+    //////////////////////////////////
+    
+    void populate_initial_block_list(size_t blockCount)
+    {
+        initialBlockPoolSize = blockCount;
+        if (initialBlockPoolSize == 0) {
+            initialBlockPool = nullptr;
+            return;
+        }
+        
+        initialBlockPool = create_array<Block>(blockCount);
+        if (initialBlockPool == nullptr) {
+            initialBlockPoolSize = 0;
+        }
+        for (size_t i = 0; i < initialBlockPoolSize; ++i) {
+            initialBlockPool[i].dynamicallyAllocated = false;
+        }
+    }
+    
+    inline Block* try_get_block_from_initial_pool()
+    {
+        if (initialBlockPoolIndex.load(std::memory_order_relaxed) >= initialBlockPoolSize) {
+            return nullptr;
+        }
+        
+        auto index = initialBlockPoolIndex.fetch_add(1, std::memory_order_relaxed);
+        
+        return index < initialBlockPoolSize ? (initialBlockPool + index) : nullptr;
+    }
+    
+    inline void add_block_to_free_list(Block* block)
+    {
 #ifdef MCDBGQ_TRACKMEM
-		block->owner = nullptr;
-#endif
-		if (!Traits::RECYCLE_ALLOCATED_BLOCKS && block->dynamicallyAllocated) {
-			destroy(block);
-		}
-		else {
-			freeList.add(block);
-		}
-	}
-	
-	inline void add_blocks_to_free_list(Block* block)
-	{
-		while (block != nullptr) {
-			auto next = block->next;
-			add_block_to_free_list(block);
-			block = next;
-		}
-	}
-	
-	inline Block* try_get_block_from_free_list()
-	{
-		return freeList.try_get();
-	}
-	
-	// Gets a free block from one of the memory pools, or allocates a new one (if applicable)
-	template<AllocationMode canAlloc>
-	Block* requisition_block()
-	{
-		auto block = try_get_block_from_initial_pool();
-		if (block != nullptr) {
-			return block;
-		}
-		
-		block = try_get_block_from_free_list();
-		if (block != nullptr) {
-			return block;
-		}
-		
-		MOODYCAMEL_CONSTEXPR_IF (canAlloc == CanAlloc) {
-			return create<Block>();
-		}
-		else {
-			return nullptr;
-		}
-	}
-	
+        block->owner = nullptr;
+#endif
+        if (!Traits::RECYCLE_ALLOCATED_BLOCKS && block->dynamicallyAllocated) {
+            destroy(block);
+        }
+        else {
+            freeList.add(block);
+        }
+    }
+    
+    inline void add_blocks_to_free_list(Block* block)
+    {
+        while (block != nullptr) {
+            auto next = block->next;
+            add_block_to_free_list(block);
+            block = next;
+        }
+    }
+    
+    inline Block* try_get_block_from_free_list()
+    {
+        return freeList.try_get();
+    }
+    
+    // Gets a free block from one of the memory pools, or allocates a new one (if applicable)
+    template<AllocationMode canAlloc>
+    Block* requisition_block()
+    {
+        auto block = try_get_block_from_initial_pool();
+        if (block != nullptr) {
+            return block;
+        }
+        
+        block = try_get_block_from_free_list();
+        if (block != nullptr) {
+            return block;
+        }
+        
+        MOODYCAMEL_CONSTEXPR_IF (canAlloc == CanAlloc) {
+            return create<Block>();
+        }
+        else {
+            return nullptr;
+        }
+    }
+    
 
 #ifdef MCDBGQ_TRACKMEM
-	public:
-		struct MemStats {
-			size_t allocatedBlocks;
-			size_t usedBlocks;
-			size_t freeBlocks;
-			size_t ownedBlocksExplicit;
-			size_t ownedBlocksImplicit;
-			size_t implicitProducers;
-			size_t explicitProducers;
-			size_t elementsEnqueued;
-			size_t blockClassBytes;
-			size_t queueClassBytes;
-			size_t implicitBlockIndexBytes;
-			size_t explicitBlockIndexBytes;
-			
-			friend class ConcurrentQueue;
-			
-		private:
-			static MemStats getFor(ConcurrentQueue* q)
-			{
-				MemStats stats = { 0 };
-				
-				stats.elementsEnqueued = q->size_approx();
-			
-				auto block = q->freeList.head_unsafe();
-				while (block != nullptr) {
-					++stats.allocatedBlocks;
-					++stats.freeBlocks;
-					block = block->freeListNext.load(std::memory_order_relaxed);
-				}
-				
-				for (auto ptr = q->producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-					bool implicit = dynamic_cast<ImplicitProducer*>(ptr) != nullptr;
-					stats.implicitProducers += implicit ? 1 : 0;
-					stats.explicitProducers += implicit ? 0 : 1;
-					
-					if (implicit) {
-						auto prod = static_cast<ImplicitProducer*>(ptr);
-						stats.queueClassBytes += sizeof(ImplicitProducer);
-						auto head = prod->headIndex.load(std::memory_order_relaxed);
-						auto tail = prod->tailIndex.load(std::memory_order_relaxed);
-						auto hash = prod->blockIndex.load(std::memory_order_relaxed);
-						if (hash != nullptr) {
-							for (size_t i = 0; i != hash->capacity; ++i) {
-								if (hash->index[i]->key.load(std::memory_order_relaxed) != ImplicitProducer::INVALID_BLOCK_BASE && hash->index[i]->value.load(std::memory_order_relaxed) != nullptr) {
-									++stats.allocatedBlocks;
-									++stats.ownedBlocksImplicit;
-								}
-							}
-							stats.implicitBlockIndexBytes += hash->capacity * sizeof(typename ImplicitProducer::BlockIndexEntry);
-							for (; hash != nullptr; hash = hash->prev) {
-								stats.implicitBlockIndexBytes += sizeof(typename ImplicitProducer::BlockIndexHeader) + hash->capacity * sizeof(typename ImplicitProducer::BlockIndexEntry*);
-							}
-						}
-						for (; details::circular_less_than<index_t>(head, tail); head += BLOCK_SIZE) {
-							//auto block = prod->get_block_index_entry_for_index(head);
-							++stats.usedBlocks;
-						}
-					}
-					else {
-						auto prod = static_cast<ExplicitProducer*>(ptr);
-						stats.queueClassBytes += sizeof(ExplicitProducer);
-						auto tailBlock = prod->tailBlock;
-						bool wasNonEmpty = false;
-						if (tailBlock != nullptr) {
-							auto block = tailBlock;
-							do {
-								++stats.allocatedBlocks;
-								if (!block->ConcurrentQueue::Block::template is_empty<explicit_context>() || wasNonEmpty) {
-									++stats.usedBlocks;
-									wasNonEmpty = wasNonEmpty || block != tailBlock;
-								}
-								++stats.ownedBlocksExplicit;
-								block = block->next;
-							} while (block != tailBlock);
-						}
-						auto index = prod->blockIndex.load(std::memory_order_relaxed);
-						while (index != nullptr) {
-							stats.explicitBlockIndexBytes += sizeof(typename ExplicitProducer::BlockIndexHeader) + index->size * sizeof(typename ExplicitProducer::BlockIndexEntry);
-							index = static_cast<typename ExplicitProducer::BlockIndexHeader*>(index->prev);
-						}
-					}
-				}
-				
-				auto freeOnInitialPool = q->initialBlockPoolIndex.load(std::memory_order_relaxed) >= q->initialBlockPoolSize ? 0 : q->initialBlockPoolSize - q->initialBlockPoolIndex.load(std::memory_order_relaxed);
-				stats.allocatedBlocks += freeOnInitialPool;
-				stats.freeBlocks += freeOnInitialPool;
-				
-				stats.blockClassBytes = sizeof(Block) * stats.allocatedBlocks;
-				stats.queueClassBytes += sizeof(ConcurrentQueue);
-				
-				return stats;
-			}
-		};
-		
-		// For debugging only. Not thread-safe.
-		MemStats getMemStats()
-		{
-			return MemStats::getFor(this);
-		}
-	private:
-		friend struct MemStats;
-#endif
-	
-	
-	//////////////////////////////////
-	// Producer list manipulation
-	//////////////////////////////////	
-	
-	ProducerBase* recycle_or_create_producer(bool isExplicit)
-	{
+    public:
+        struct MemStats {
+            size_t allocatedBlocks;
+            size_t usedBlocks;
+            size_t freeBlocks;
+            size_t ownedBlocksExplicit;
+            size_t ownedBlocksImplicit;
+            size_t implicitProducers;
+            size_t explicitProducers;
+            size_t elementsEnqueued;
+            size_t blockClassBytes;
+            size_t queueClassBytes;
+            size_t implicitBlockIndexBytes;
+            size_t explicitBlockIndexBytes;
+            
+            friend class ConcurrentQueue;
+            
+        private:
+            static MemStats getFor(ConcurrentQueue* q)
+            {
+                MemStats stats = { 0 };
+                
+                stats.elementsEnqueued = q->size_approx();
+            
+                auto block = q->freeList.head_unsafe();
+                while (block != nullptr) {
+                    ++stats.allocatedBlocks;
+                    ++stats.freeBlocks;
+                    block = block->freeListNext.load(std::memory_order_relaxed);
+                }
+                
+                for (auto ptr = q->producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+                    bool implicit = dynamic_cast<ImplicitProducer*>(ptr) != nullptr;
+                    stats.implicitProducers += implicit ? 1 : 0;
+                    stats.explicitProducers += implicit ? 0 : 1;
+                    
+                    if (implicit) {
+                        auto prod = static_cast<ImplicitProducer*>(ptr);
+                        stats.queueClassBytes += sizeof(ImplicitProducer);
+                        auto head = prod->headIndex.load(std::memory_order_relaxed);
+                        auto tail = prod->tailIndex.load(std::memory_order_relaxed);
+                        auto hash = prod->blockIndex.load(std::memory_order_relaxed);
+                        if (hash != nullptr) {
+                            for (size_t i = 0; i != hash->capacity; ++i) {
+                                if (hash->index[i]->key.load(std::memory_order_relaxed) != ImplicitProducer::INVALID_BLOCK_BASE && hash->index[i]->value.load(std::memory_order_relaxed) != nullptr) {
+                                    ++stats.allocatedBlocks;
+                                    ++stats.ownedBlocksImplicit;
+                                }
+                            }
+                            stats.implicitBlockIndexBytes += hash->capacity * sizeof(typename ImplicitProducer::BlockIndexEntry);
+                            for (; hash != nullptr; hash = hash->prev) {
+                                stats.implicitBlockIndexBytes += sizeof(typename ImplicitProducer::BlockIndexHeader) + hash->capacity * sizeof(typename ImplicitProducer::BlockIndexEntry*);
+                            }
+                        }
+                        for (; details::circular_less_than<index_t>(head, tail); head += BLOCK_SIZE) {
+                            //auto block = prod->get_block_index_entry_for_index(head);
+                            ++stats.usedBlocks;
+                        }
+                    }
+                    else {
+                        auto prod = static_cast<ExplicitProducer*>(ptr);
+                        stats.queueClassBytes += sizeof(ExplicitProducer);
+                        auto tailBlock = prod->tailBlock;
+                        bool wasNonEmpty = false;
+                        if (tailBlock != nullptr) {
+                            auto block = tailBlock;
+                            do {
+                                ++stats.allocatedBlocks;
+                                if (!block->ConcurrentQueue::Block::template is_empty<explicit_context>() || wasNonEmpty) {
+                                    ++stats.usedBlocks;
+                                    wasNonEmpty = wasNonEmpty || block != tailBlock;
+                                }
+                                ++stats.ownedBlocksExplicit;
+                                block = block->next;
+                            } while (block != tailBlock);
+                        }
+                        auto index = prod->blockIndex.load(std::memory_order_relaxed);
+                        while (index != nullptr) {
+                            stats.explicitBlockIndexBytes += sizeof(typename ExplicitProducer::BlockIndexHeader) + index->size * sizeof(typename ExplicitProducer::BlockIndexEntry);
+                            index = static_cast<typename ExplicitProducer::BlockIndexHeader*>(index->prev);
+                        }
+                    }
+                }
+                
+                auto freeOnInitialPool = q->initialBlockPoolIndex.load(std::memory_order_relaxed) >= q->initialBlockPoolSize ? 0 : q->initialBlockPoolSize - q->initialBlockPoolIndex.load(std::memory_order_relaxed);
+                stats.allocatedBlocks += freeOnInitialPool;
+                stats.freeBlocks += freeOnInitialPool;
+                
+                stats.blockClassBytes = sizeof(Block) * stats.allocatedBlocks;
+                stats.queueClassBytes += sizeof(ConcurrentQueue);
+                
+                return stats;
+            }
+        };
+        
+        // For debugging only. Not thread-safe.
+        MemStats getMemStats()
+        {
+            return MemStats::getFor(this);
+        }
+    private:
+        friend struct MemStats;
+#endif
+    
+    
+    //////////////////////////////////
+    // Producer list manipulation
+    //////////////////////////////////	
+    
+    ProducerBase* recycle_or_create_producer(bool isExplicit)
+    {
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-		debug::DebugLock lock(implicitProdMutex);
-#endif
-		// Try to re-use one first
-		for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
-			if (ptr->inactive.load(std::memory_order_relaxed) && ptr->isExplicit == isExplicit) {
-				bool expected = true;
-				if (ptr->inactive.compare_exchange_strong(expected, /* desired */ false, std::memory_order_acquire, std::memory_order_relaxed)) {
-					// We caught one! It's been marked as activated, the caller can have it
-					return ptr;
-				}
-			}
-		}
-
-		return add_producer(isExplicit ? static_cast<ProducerBase*>(create<ExplicitProducer>(this)) : create<ImplicitProducer>(this));
-	}
-	
-	ProducerBase* add_producer(ProducerBase* producer)
-	{
-		// Handle failed memory allocation
-		if (producer == nullptr) {
-			return nullptr;
-		}
-		
-		producerCount.fetch_add(1, std::memory_order_relaxed);
-		
-		// Add it to the lock-free list
-		auto prevTail = producerListTail.load(std::memory_order_relaxed);
-		do {
-			producer->next = prevTail;
-		} while (!producerListTail.compare_exchange_weak(prevTail, producer, std::memory_order_release, std::memory_order_relaxed));
-		
+        debug::DebugLock lock(implicitProdMutex);
+#endif
+        // Try to re-use one first
+        for (auto ptr = producerListTail.load(std::memory_order_acquire); ptr != nullptr; ptr = ptr->next_prod()) {
+            if (ptr->inactive.load(std::memory_order_relaxed) && ptr->isExplicit == isExplicit) {
+                bool expected = true;
+                if (ptr->inactive.compare_exchange_strong(expected, /* desired */ false, std::memory_order_acquire, std::memory_order_relaxed)) {
+                    // We caught one! It's been marked as activated, the caller can have it
+                    return ptr;
+                }
+            }
+        }
+
+        return add_producer(isExplicit ? static_cast<ProducerBase*>(create<ExplicitProducer>(this)) : create<ImplicitProducer>(this));
+    }
+    
+    ProducerBase* add_producer(ProducerBase* producer)
+    {
+        // Handle failed memory allocation
+        if (producer == nullptr) {
+            return nullptr;
+        }
+        
+        producerCount.fetch_add(1, std::memory_order_relaxed);
+        
+        // Add it to the lock-free list
+        auto prevTail = producerListTail.load(std::memory_order_relaxed);
+        do {
+            producer->next = prevTail;
+        } while (!producerListTail.compare_exchange_weak(prevTail, producer, std::memory_order_release, std::memory_order_relaxed));
+        
 #ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-		if (producer->isExplicit) {
-			auto prevTailExplicit = explicitProducers.load(std::memory_order_relaxed);
-			do {
-				static_cast<ExplicitProducer*>(producer)->nextExplicitProducer = prevTailExplicit;
-			} while (!explicitProducers.compare_exchange_weak(prevTailExplicit, static_cast<ExplicitProducer*>(producer), std::memory_order_release, std::memory_order_relaxed));
-		}
-		else {
-			auto prevTailImplicit = implicitProducers.load(std::memory_order_relaxed);
-			do {
-				static_cast<ImplicitProducer*>(producer)->nextImplicitProducer = prevTailImplicit;
-			} while (!implicitProducers.compare_exchange_weak(prevTailImplicit, static_cast<ImplicitProducer*>(producer), std::memory_order_release, std::memory_order_relaxed));
-		}
-#endif
-		
-		return producer;
-	}
-	
-	void reown_producers()
-	{
-		// After another instance is moved-into/swapped-with this one, all the
-		// producers we stole still think their parents are the other queue.
-		// So fix them up!
-		for (auto ptr = producerListTail.load(std::memory_order_relaxed); ptr != nullptr; ptr = ptr->next_prod()) {
-			ptr->parent = this;
-		}
-	}
-	
-	
-	//////////////////////////////////
-	// Implicit producer hash
-	//////////////////////////////////
-	
-	struct ImplicitProducerKVP
-	{
-		std::atomic<details::thread_id_t> key;
-		ImplicitProducer* value;		// No need for atomicity since it's only read by the thread that sets it in the first place
-		
-		ImplicitProducerKVP() : value(nullptr) { }
-		
-		ImplicitProducerKVP(ImplicitProducerKVP&& other) MOODYCAMEL_NOEXCEPT
-		{
-			key.store(other.key.load(std::memory_order_relaxed), std::memory_order_relaxed);
-			value = other.value;
-		}
-		
-		inline ImplicitProducerKVP& operator=(ImplicitProducerKVP&& other) MOODYCAMEL_NOEXCEPT
-		{
-			swap(other);
-			return *this;
-		}
-		
-		inline void swap(ImplicitProducerKVP& other) MOODYCAMEL_NOEXCEPT
-		{
-			if (this != &other) {
-				details::swap_relaxed(key, other.key);
-				std::swap(value, other.value);
-			}
-		}
-	};
-	
-	template<typename XT, typename XTraits>
-	friend void moodycamel::swap(typename ConcurrentQueue<XT, XTraits>::ImplicitProducerKVP&, typename ConcurrentQueue<XT, XTraits>::ImplicitProducerKVP&) MOODYCAMEL_NOEXCEPT;
-	
-	struct ImplicitProducerHash
-	{
-		size_t capacity;
-		ImplicitProducerKVP* entries;
-		ImplicitProducerHash* prev;
-	};
-	
-	inline void populate_initial_implicit_producer_hash()
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) {
-			return;
-		}
-		else {
-			implicitProducerHashCount.store(0, std::memory_order_relaxed);
-			auto hash = &initialImplicitProducerHash;
-			hash->capacity = INITIAL_IMPLICIT_PRODUCER_HASH_SIZE;
-			hash->entries = &initialImplicitProducerHashEntries[0];
-			for (size_t i = 0; i != INITIAL_IMPLICIT_PRODUCER_HASH_SIZE; ++i) {
-				initialImplicitProducerHashEntries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
-			}
-			hash->prev = nullptr;
-			implicitProducerHash.store(hash, std::memory_order_relaxed);
-		}
-	}
-	
-	void swap_implicit_producer_hashes(ConcurrentQueue& other)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) {
-			return;
-		}
-		else {
-			// Swap (assumes our implicit producer hash is initialized)
-			initialImplicitProducerHashEntries.swap(other.initialImplicitProducerHashEntries);
-			initialImplicitProducerHash.entries = &initialImplicitProducerHashEntries[0];
-			other.initialImplicitProducerHash.entries = &other.initialImplicitProducerHashEntries[0];
-			
-			details::swap_relaxed(implicitProducerHashCount, other.implicitProducerHashCount);
-			
-			details::swap_relaxed(implicitProducerHash, other.implicitProducerHash);
-			if (implicitProducerHash.load(std::memory_order_relaxed) == &other.initialImplicitProducerHash) {
-				implicitProducerHash.store(&initialImplicitProducerHash, std::memory_order_relaxed);
-			}
-			else {
-				ImplicitProducerHash* hash;
-				for (hash = implicitProducerHash.load(std::memory_order_relaxed); hash->prev != &other.initialImplicitProducerHash; hash = hash->prev) {
-					continue;
-				}
-				hash->prev = &initialImplicitProducerHash;
-			}
-			if (other.implicitProducerHash.load(std::memory_order_relaxed) == &initialImplicitProducerHash) {
-				other.implicitProducerHash.store(&other.initialImplicitProducerHash, std::memory_order_relaxed);
-			}
-			else {
-				ImplicitProducerHash* hash;
-				for (hash = other.implicitProducerHash.load(std::memory_order_relaxed); hash->prev != &initialImplicitProducerHash; hash = hash->prev) {
-					continue;
-				}
-				hash->prev = &other.initialImplicitProducerHash;
-			}
-		}
-	}
-	
-	// Only fails (returns nullptr) if memory allocation fails
-	ImplicitProducer* get_or_add_implicit_producer()
-	{
-		// Note that since the data is essentially thread-local (key is thread ID),
-		// there's a reduced need for fences (memory ordering is already consistent
-		// for any individual thread), except for the current table itself.
-		
-		// Start by looking for the thread ID in the current and all previous hash tables.
-		// If it's not found, it must not be in there yet, since this same thread would
-		// have added it previously to one of the tables that we traversed.
-		
-		// Code and algorithm adapted from http://preshing.com/20130605/the-worlds-simplest-lock-free-hash-table
-		
+        if (producer->isExplicit) {
+            auto prevTailExplicit = explicitProducers.load(std::memory_order_relaxed);
+            do {
+                static_cast<ExplicitProducer*>(producer)->nextExplicitProducer = prevTailExplicit;
+            } while (!explicitProducers.compare_exchange_weak(prevTailExplicit, static_cast<ExplicitProducer*>(producer), std::memory_order_release, std::memory_order_relaxed));
+        }
+        else {
+            auto prevTailImplicit = implicitProducers.load(std::memory_order_relaxed);
+            do {
+                static_cast<ImplicitProducer*>(producer)->nextImplicitProducer = prevTailImplicit;
+            } while (!implicitProducers.compare_exchange_weak(prevTailImplicit, static_cast<ImplicitProducer*>(producer), std::memory_order_release, std::memory_order_relaxed));
+        }
+#endif
+        
+        return producer;
+    }
+    
+    void reown_producers()
+    {
+        // After another instance is moved-into/swapped-with this one, all the
+        // producers we stole still think their parents are the other queue.
+        // So fix them up!
+        for (auto ptr = producerListTail.load(std::memory_order_relaxed); ptr != nullptr; ptr = ptr->next_prod()) {
+            ptr->parent = this;
+        }
+    }
+    
+    
+    //////////////////////////////////
+    // Implicit producer hash
+    //////////////////////////////////
+    
+    struct ImplicitProducerKVP
+    {
+        std::atomic<details::thread_id_t> key;
+        ImplicitProducer* value;		// No need for atomicity since it's only read by the thread that sets it in the first place
+        
+        ImplicitProducerKVP() : value(nullptr) { }
+        
+        ImplicitProducerKVP(ImplicitProducerKVP&& other) MOODYCAMEL_NOEXCEPT
+        {
+            key.store(other.key.load(std::memory_order_relaxed), std::memory_order_relaxed);
+            value = other.value;
+        }
+        
+        inline ImplicitProducerKVP& operator=(ImplicitProducerKVP&& other) MOODYCAMEL_NOEXCEPT
+        {
+            swap(other);
+            return *this;
+        }
+        
+        inline void swap(ImplicitProducerKVP& other) MOODYCAMEL_NOEXCEPT
+        {
+            if (this != &other) {
+                details::swap_relaxed(key, other.key);
+                std::swap(value, other.value);
+            }
+        }
+    };
+    
+    template<typename XT, typename XTraits>
+    friend void moodycamel::swap(typename ConcurrentQueue<XT, XTraits>::ImplicitProducerKVP&, typename ConcurrentQueue<XT, XTraits>::ImplicitProducerKVP&) MOODYCAMEL_NOEXCEPT;
+    
+    struct ImplicitProducerHash
+    {
+        size_t capacity;
+        ImplicitProducerKVP* entries;
+        ImplicitProducerHash* prev;
+    };
+    
+    inline void populate_initial_implicit_producer_hash()
+    {
+        MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) {
+            return;
+        }
+        else {
+            implicitProducerHashCount.store(0, std::memory_order_relaxed);
+            auto hash = &initialImplicitProducerHash;
+            hash->capacity = INITIAL_IMPLICIT_PRODUCER_HASH_SIZE;
+            hash->entries = &initialImplicitProducerHashEntries[0];
+            for (size_t i = 0; i != INITIAL_IMPLICIT_PRODUCER_HASH_SIZE; ++i) {
+                initialImplicitProducerHashEntries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
+            }
+            hash->prev = nullptr;
+            implicitProducerHash.store(hash, std::memory_order_relaxed);
+        }
+    }
+    
+    void swap_implicit_producer_hashes(ConcurrentQueue& other)
+    {
+        MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) {
+            return;
+        }
+        else {
+            // Swap (assumes our implicit producer hash is initialized)
+            initialImplicitProducerHashEntries.swap(other.initialImplicitProducerHashEntries);
+            initialImplicitProducerHash.entries = &initialImplicitProducerHashEntries[0];
+            other.initialImplicitProducerHash.entries = &other.initialImplicitProducerHashEntries[0];
+            
+            details::swap_relaxed(implicitProducerHashCount, other.implicitProducerHashCount);
+            
+            details::swap_relaxed(implicitProducerHash, other.implicitProducerHash);
+            if (implicitProducerHash.load(std::memory_order_relaxed) == &other.initialImplicitProducerHash) {
+                implicitProducerHash.store(&initialImplicitProducerHash, std::memory_order_relaxed);
+            }
+            else {
+                ImplicitProducerHash* hash;
+                for (hash = implicitProducerHash.load(std::memory_order_relaxed); hash->prev != &other.initialImplicitProducerHash; hash = hash->prev) {
+                    continue;
+                }
+                hash->prev = &initialImplicitProducerHash;
+            }
+            if (other.implicitProducerHash.load(std::memory_order_relaxed) == &initialImplicitProducerHash) {
+                other.implicitProducerHash.store(&other.initialImplicitProducerHash, std::memory_order_relaxed);
+            }
+            else {
+                ImplicitProducerHash* hash;
+                for (hash = other.implicitProducerHash.load(std::memory_order_relaxed); hash->prev != &initialImplicitProducerHash; hash = hash->prev) {
+                    continue;
+                }
+                hash->prev = &other.initialImplicitProducerHash;
+            }
+        }
+    }
+    
+    // Only fails (returns nullptr) if memory allocation fails
+    ImplicitProducer* get_or_add_implicit_producer()
+    {
+        // Note that since the data is essentially thread-local (key is thread ID),
+        // there's a reduced need for fences (memory ordering is already consistent
+        // for any individual thread), except for the current table itself.
+        
+        // Start by looking for the thread ID in the current and all previous hash tables.
+        // If it's not found, it must not be in there yet, since this same thread would
+        // have added it previously to one of the tables that we traversed.
+        
+        // Code and algorithm adapted from http://preshing.com/20130605/the-worlds-simplest-lock-free-hash-table
+        
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-		debug::DebugLock lock(implicitProdMutex);
-#endif
-		
-		auto id = details::thread_id();
-		auto hashedId = details::hash_thread_id(id);
-		
-		auto mainHash = implicitProducerHash.load(std::memory_order_acquire);
-		assert(mainHash != nullptr);  // silence clang-tidy and MSVC warnings (hash cannot be null)
-		for (auto hash = mainHash; hash != nullptr; hash = hash->prev) {
-			// Look for the id in this hash
-			auto index = hashedId;
-			while (true) {		// Not an infinite loop because at least one slot is free in the hash table
-				index &= hash->capacity - 1u;
-				
-				auto probedKey = hash->entries[index].key.load(std::memory_order_relaxed);
-				if (probedKey == id) {
-					// Found it! If we had to search several hashes deep, though, we should lazily add it
-					// to the current main hash table to avoid the extended search next time.
-					// Note there's guaranteed to be room in the current hash table since every subsequent
-					// table implicitly reserves space for all previous tables (there's only one
-					// implicitProducerHashCount).
-					auto value = hash->entries[index].value;
-					if (hash != mainHash) {
-						index = hashedId;
-						while (true) {
-							index &= mainHash->capacity - 1u;
-							auto empty = details::invalid_thread_id;
+        debug::DebugLock lock(implicitProdMutex);
+#endif
+        
+        auto id = details::thread_id();
+        auto hashedId = details::hash_thread_id(id);
+        
+        auto mainHash = implicitProducerHash.load(std::memory_order_acquire);
+        assert(mainHash != nullptr);  // silence clang-tidy and MSVC warnings (hash cannot be null)
+        for (auto hash = mainHash; hash != nullptr; hash = hash->prev) {
+            // Look for the id in this hash
+            auto index = hashedId;
+            while (true) {		// Not an infinite loop because at least one slot is free in the hash table
+                index &= hash->capacity - 1u;
+                
+                auto probedKey = hash->entries[index].key.load(std::memory_order_relaxed);
+                if (probedKey == id) {
+                    // Found it! If we had to search several hashes deep, though, we should lazily add it
+                    // to the current main hash table to avoid the extended search next time.
+                    // Note there's guaranteed to be room in the current hash table since every subsequent
+                    // table implicitly reserves space for all previous tables (there's only one
+                    // implicitProducerHashCount).
+                    auto value = hash->entries[index].value;
+                    if (hash != mainHash) {
+                        index = hashedId;
+                        while (true) {
+                            index &= mainHash->capacity - 1u;
+                            auto empty = details::invalid_thread_id;
 #ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-							auto reusable = details::invalid_thread_id2;
-							if (mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_seq_cst, std::memory_order_relaxed) ||
-								mainHash->entries[index].key.compare_exchange_strong(reusable, id, std::memory_order_seq_cst, std::memory_order_relaxed)) {
+                            auto reusable = details::invalid_thread_id2;
+                            if (mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_seq_cst, std::memory_order_relaxed) ||
+                                mainHash->entries[index].key.compare_exchange_strong(reusable, id, std::memory_order_seq_cst, std::memory_order_relaxed)) {
 #else
-							if (mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_seq_cst, std::memory_order_relaxed)) {
-#endif
-								mainHash->entries[index].value = value;
-								break;
-							}
-							++index;
-						}
-					}
-					
-					return value;
-				}
-				if (probedKey == details::invalid_thread_id) {
-					break;		// Not in this hash table
-				}
-				++index;
-			}
-		}
-		
-		// Insert!
-		auto newCount = 1 + implicitProducerHashCount.fetch_add(1, std::memory_order_relaxed);
-		while (true) {
-			// NOLINTNEXTLINE(clang-analyzer-core.NullDereference)
-			if (newCount >= (mainHash->capacity >> 1) && !implicitProducerHashResizeInProgress.test_and_set(std::memory_order_acquire)) {
-				// We've acquired the resize lock, try to allocate a bigger hash table.
-				// Note the acquire fence synchronizes with the release fence at the end of this block, and hence when
-				// we reload implicitProducerHash it must be the most recent version (it only gets changed within this
-				// locked block).
-				mainHash = implicitProducerHash.load(std::memory_order_acquire);
-				if (newCount >= (mainHash->capacity >> 1)) {
-					size_t newCapacity = mainHash->capacity << 1;
-					while (newCount >= (newCapacity >> 1)) {
-						newCapacity <<= 1;
-					}
-					auto raw = static_cast<char*>((Traits::malloc)(sizeof(ImplicitProducerHash) + std::alignment_of<ImplicitProducerKVP>::value - 1 + sizeof(ImplicitProducerKVP) * newCapacity));
-					if (raw == nullptr) {
-						// Allocation failed
-						implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
-						implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
-						return nullptr;
-					}
-					
-					auto newHash = new (raw) ImplicitProducerHash;
-					newHash->capacity = static_cast<size_t>(newCapacity);
-					newHash->entries = reinterpret_cast<ImplicitProducerKVP*>(details::align_for<ImplicitProducerKVP>(raw + sizeof(ImplicitProducerHash)));
-					for (size_t i = 0; i != newCapacity; ++i) {
-						new (newHash->entries + i) ImplicitProducerKVP;
-						newHash->entries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
-					}
-					newHash->prev = mainHash;
-					implicitProducerHash.store(newHash, std::memory_order_release);
-					implicitProducerHashResizeInProgress.clear(std::memory_order_release);
-					mainHash = newHash;
-				}
-				else {
-					implicitProducerHashResizeInProgress.clear(std::memory_order_release);
-				}
-			}
-			
-			// If it's < three-quarters full, add to the old one anyway so that we don't have to wait for the next table
-			// to finish being allocated by another thread (and if we just finished allocating above, the condition will
-			// always be true)
-			if (newCount < (mainHash->capacity >> 1) + (mainHash->capacity >> 2)) {
-				auto producer = static_cast<ImplicitProducer*>(recycle_or_create_producer(false));
-				if (producer == nullptr) {
-					implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
-					return nullptr;
-				}
-				
+                            if (mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_seq_cst, std::memory_order_relaxed)) {
+#endif
+                                mainHash->entries[index].value = value;
+                                break;
+                            }
+                            ++index;
+                        }
+                    }
+                    
+                    return value;
+                }
+                if (probedKey == details::invalid_thread_id) {
+                    break;		// Not in this hash table
+                }
+                ++index;
+            }
+        }
+        
+        // Insert!
+        auto newCount = 1 + implicitProducerHashCount.fetch_add(1, std::memory_order_relaxed);
+        while (true) {
+            // NOLINTNEXTLINE(clang-analyzer-core.NullDereference)
+            if (newCount >= (mainHash->capacity >> 1) && !implicitProducerHashResizeInProgress.test_and_set(std::memory_order_acquire)) {
+                // We've acquired the resize lock, try to allocate a bigger hash table.
+                // Note the acquire fence synchronizes with the release fence at the end of this block, and hence when
+                // we reload implicitProducerHash it must be the most recent version (it only gets changed within this
+                // locked block).
+                mainHash = implicitProducerHash.load(std::memory_order_acquire);
+                if (newCount >= (mainHash->capacity >> 1)) {
+                    size_t newCapacity = mainHash->capacity << 1;
+                    while (newCount >= (newCapacity >> 1)) {
+                        newCapacity <<= 1;
+                    }
+                    auto raw = static_cast<char*>((Traits::malloc)(sizeof(ImplicitProducerHash) + std::alignment_of<ImplicitProducerKVP>::value - 1 + sizeof(ImplicitProducerKVP) * newCapacity));
+                    if (raw == nullptr) {
+                        // Allocation failed
+                        implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
+                        implicitProducerHashResizeInProgress.clear(std::memory_order_relaxed);
+                        return nullptr;
+                    }
+                    
+                    auto newHash = new (raw) ImplicitProducerHash;
+                    newHash->capacity = static_cast<size_t>(newCapacity);
+                    newHash->entries = reinterpret_cast<ImplicitProducerKVP*>(details::align_for<ImplicitProducerKVP>(raw + sizeof(ImplicitProducerHash)));
+                    for (size_t i = 0; i != newCapacity; ++i) {
+                        new (newHash->entries + i) ImplicitProducerKVP;
+                        newHash->entries[i].key.store(details::invalid_thread_id, std::memory_order_relaxed);
+                    }
+                    newHash->prev = mainHash;
+                    implicitProducerHash.store(newHash, std::memory_order_release);
+                    implicitProducerHashResizeInProgress.clear(std::memory_order_release);
+                    mainHash = newHash;
+                }
+                else {
+                    implicitProducerHashResizeInProgress.clear(std::memory_order_release);
+                }
+            }
+            
+            // If it's < three-quarters full, add to the old one anyway so that we don't have to wait for the next table
+            // to finish being allocated by another thread (and if we just finished allocating above, the condition will
+            // always be true)
+            if (newCount < (mainHash->capacity >> 1) + (mainHash->capacity >> 2)) {
+                auto producer = static_cast<ImplicitProducer*>(recycle_or_create_producer(false));
+                if (producer == nullptr) {
+                    implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);
+                    return nullptr;
+                }
+                
 #ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-				producer->threadExitListener.callback = &ConcurrentQueue::implicit_producer_thread_exited_callback;
-				producer->threadExitListener.userData = producer;
-				details::ThreadExitNotifier::subscribe(&producer->threadExitListener);
-#endif
-				
-				auto index = hashedId;
-				while (true) {
-					index &= mainHash->capacity - 1u;
-					auto empty = details::invalid_thread_id;
+                producer->threadExitListener.callback = &ConcurrentQueue::implicit_producer_thread_exited_callback;
+                producer->threadExitListener.userData = producer;
+                details::ThreadExitNotifier::subscribe(&producer->threadExitListener);
+#endif
+                
+                auto index = hashedId;
+                while (true) {
+                    index &= mainHash->capacity - 1u;
+                    auto empty = details::invalid_thread_id;
 #ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-					auto reusable = details::invalid_thread_id2;
-					if (mainHash->entries[index].key.compare_exchange_strong(reusable, id, std::memory_order_seq_cst, std::memory_order_relaxed)) {
-						implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);  // already counted as a used slot
-						mainHash->entries[index].value = producer;
-						break;
-					}
-#endif
-					if (mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_seq_cst, std::memory_order_relaxed)) {
-						mainHash->entries[index].value = producer;
-						break;
-					}
-					++index;
-				}
-				return producer;
-			}
-			
-			// Hmm, the old hash is quite full and somebody else is busy allocating a new one.
-			// We need to wait for the allocating thread to finish (if it succeeds, we add, if not,
-			// we try to allocate ourselves).
-			mainHash = implicitProducerHash.load(std::memory_order_acquire);
-		}
-	}
-	
+                    auto reusable = details::invalid_thread_id2;
+                    if (mainHash->entries[index].key.compare_exchange_strong(reusable, id, std::memory_order_seq_cst, std::memory_order_relaxed)) {
+                        implicitProducerHashCount.fetch_sub(1, std::memory_order_relaxed);  // already counted as a used slot
+                        mainHash->entries[index].value = producer;
+                        break;
+                    }
+#endif
+                    if (mainHash->entries[index].key.compare_exchange_strong(empty,    id, std::memory_order_seq_cst, std::memory_order_relaxed)) {
+                        mainHash->entries[index].value = producer;
+                        break;
+                    }
+                    ++index;
+                }
+                return producer;
+            }
+            
+            // Hmm, the old hash is quite full and somebody else is busy allocating a new one.
+            // We need to wait for the allocating thread to finish (if it succeeds, we add, if not,
+            // we try to allocate ourselves).
+            mainHash = implicitProducerHash.load(std::memory_order_acquire);
+        }
+    }
+    
 #ifdef MOODYCAMEL_CPP11_THREAD_LOCAL_SUPPORTED
-	void implicit_producer_thread_exited(ImplicitProducer* producer)
-	{
-		// Remove from hash
+    void implicit_producer_thread_exited(ImplicitProducer* producer)
+    {
+        // Remove from hash
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-		debug::DebugLock lock(implicitProdMutex);
-#endif
-		auto hash = implicitProducerHash.load(std::memory_order_acquire);
-		assert(hash != nullptr);		// The thread exit listener is only registered if we were added to a hash in the first place
-		auto id = details::thread_id();
-		auto hashedId = details::hash_thread_id(id);
-		details::thread_id_t probedKey;
-		
-		// We need to traverse all the hashes just in case other threads aren't on the current one yet and are
-		// trying to add an entry thinking there's a free slot (because they reused a producer)
-		for (; hash != nullptr; hash = hash->prev) {
-			auto index = hashedId;
-			do {
-				index &= hash->capacity - 1u;
-				probedKey = id;
-				if (hash->entries[index].key.compare_exchange_strong(probedKey, details::invalid_thread_id2, std::memory_order_seq_cst, std::memory_order_relaxed)) {
-					break;
-				}
-				++index;
-			} while (probedKey != details::invalid_thread_id);		// Can happen if the hash has changed but we weren't put back in it yet, or if we weren't added to this hash in the first place
-		}
-		
-		// Mark the queue as being recyclable
-		producer->inactive.store(true, std::memory_order_release);
-	}
-	
-	static void implicit_producer_thread_exited_callback(void* userData)
-	{
-		auto producer = static_cast<ImplicitProducer*>(userData);
-		auto queue = producer->parent;
-		queue->implicit_producer_thread_exited(producer);
-	}
-#endif
-	
-	//////////////////////////////////
-	// Utility functions
-	//////////////////////////////////
-
-	template<typename TAlign>
-	static inline void* aligned_malloc(size_t size)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (std::alignment_of<TAlign>::value <= std::alignment_of<details::max_align_t>::value)
-			return (Traits::malloc)(size);
-		else {
-			size_t alignment = std::alignment_of<TAlign>::value;
-			void* raw = (Traits::malloc)(size + alignment - 1 + sizeof(void*));
-			if (!raw)
-				return nullptr;
-			char* ptr = details::align_for<TAlign>(reinterpret_cast<char*>(raw) + sizeof(void*));
-			*(reinterpret_cast<void**>(ptr) - 1) = raw;
-			return ptr;
-		}
-	}
-
-	template<typename TAlign>
-	static inline void aligned_free(void* ptr)
-	{
-		MOODYCAMEL_CONSTEXPR_IF (std::alignment_of<TAlign>::value <= std::alignment_of<details::max_align_t>::value)
-			return (Traits::free)(ptr);
-		else
-			(Traits::free)(ptr ? *(reinterpret_cast<void**>(ptr) - 1) : nullptr);
-	}
-
-	template<typename U>
-	static inline U* create_array(size_t count)
-	{
-		assert(count > 0);
-		U* p = static_cast<U*>(aligned_malloc<U>(sizeof(U) * count));
-		if (p == nullptr)
-			return nullptr;
-
-		for (size_t i = 0; i != count; ++i)
-			new (p + i) U();
-		return p;
-	}
-
-	template<typename U>
-	static inline void destroy_array(U* p, size_t count)
-	{
-		if (p != nullptr) {
-			assert(count > 0);
-			for (size_t i = count; i != 0; )
-				(p + --i)->~U();
-		}
-		aligned_free<U>(p);
-	}
-
-	template<typename U>
-	static inline U* create()
-	{
-		void* p = aligned_malloc<U>(sizeof(U));
-		return p != nullptr ? new (p) U : nullptr;
-	}
-
-	template<typename U, typename A1>
-	static inline U* create(A1&& a1)
-	{
-		void* p = aligned_malloc<U>(sizeof(U));
-		return p != nullptr ? new (p) U(std::forward<A1>(a1)) : nullptr;
-	}
-
-	template<typename U>
-	static inline void destroy(U* p)
-	{
-		if (p != nullptr)
-			p->~U();
-		aligned_free<U>(p);
-	}
+        debug::DebugLock lock(implicitProdMutex);
+#endif
+        auto hash = implicitProducerHash.load(std::memory_order_acquire);
+        assert(hash != nullptr);		// The thread exit listener is only registered if we were added to a hash in the first place
+        auto id = details::thread_id();
+        auto hashedId = details::hash_thread_id(id);
+        details::thread_id_t probedKey;
+        
+        // We need to traverse all the hashes just in case other threads aren't on the current one yet and are
+        // trying to add an entry thinking there's a free slot (because they reused a producer)
+        for (; hash != nullptr; hash = hash->prev) {
+            auto index = hashedId;
+            do {
+                index &= hash->capacity - 1u;
+                probedKey = id;
+                if (hash->entries[index].key.compare_exchange_strong(probedKey, details::invalid_thread_id2, std::memory_order_seq_cst, std::memory_order_relaxed)) {
+                    break;
+                }
+                ++index;
+            } while (probedKey != details::invalid_thread_id);		// Can happen if the hash has changed but we weren't put back in it yet, or if we weren't added to this hash in the first place
+        }
+        
+        // Mark the queue as being recyclable
+        producer->inactive.store(true, std::memory_order_release);
+    }
+    
+    static void implicit_producer_thread_exited_callback(void* userData)
+    {
+        auto producer = static_cast<ImplicitProducer*>(userData);
+        auto queue = producer->parent;
+        queue->implicit_producer_thread_exited(producer);
+    }
+#endif
+    
+    //////////////////////////////////
+    // Utility functions
+    //////////////////////////////////
+
+    template<typename TAlign>
+    static inline void* aligned_malloc(size_t size)
+    {
+        MOODYCAMEL_CONSTEXPR_IF (std::alignment_of<TAlign>::value <= std::alignment_of<details::max_align_t>::value)
+            return (Traits::malloc)(size);
+        else {
+            size_t alignment = std::alignment_of<TAlign>::value;
+            void* raw = (Traits::malloc)(size + alignment - 1 + sizeof(void*));
+            if (!raw)
+                return nullptr;
+            char* ptr = details::align_for<TAlign>(reinterpret_cast<char*>(raw) + sizeof(void*));
+            *(reinterpret_cast<void**>(ptr) - 1) = raw;
+            return ptr;
+        }
+    }
+
+    template<typename TAlign>
+    static inline void aligned_free(void* ptr)
+    {
+        MOODYCAMEL_CONSTEXPR_IF (std::alignment_of<TAlign>::value <= std::alignment_of<details::max_align_t>::value)
+            return (Traits::free)(ptr);
+        else
+            (Traits::free)(ptr ? *(reinterpret_cast<void**>(ptr) - 1) : nullptr);
+    }
+
+    template<typename U>
+    static inline U* create_array(size_t count)
+    {
+        assert(count > 0);
+        U* p = static_cast<U*>(aligned_malloc<U>(sizeof(U) * count));
+        if (p == nullptr)
+            return nullptr;
+
+        for (size_t i = 0; i != count; ++i)
+            new (p + i) U();
+        return p;
+    }
+
+    template<typename U>
+    static inline void destroy_array(U* p, size_t count)
+    {
+        if (p != nullptr) {
+            assert(count > 0);
+            for (size_t i = count; i != 0; )
+                (p + --i)->~U();
+        }
+        aligned_free<U>(p);
+    }
+
+    template<typename U>
+    static inline U* create()
+    {
+        void* p = aligned_malloc<U>(sizeof(U));
+        return p != nullptr ? new (p) U : nullptr;
+    }
+
+    template<typename U, typename A1>
+    static inline U* create(A1&& a1)
+    {
+        void* p = aligned_malloc<U>(sizeof(U));
+        return p != nullptr ? new (p) U(std::forward<A1>(a1)) : nullptr;
+    }
+
+    template<typename U>
+    static inline void destroy(U* p)
+    {
+        if (p != nullptr)
+            p->~U();
+        aligned_free<U>(p);
+    }
 
 private:
-	std::atomic<ProducerBase*> producerListTail;
-	std::atomic<std::uint32_t> producerCount;
-	
-	std::atomic<size_t> initialBlockPoolIndex;
-	Block* initialBlockPool;
-	size_t initialBlockPoolSize;
-	
+    std::atomic<ProducerBase*> producerListTail;
+    std::atomic<std::uint32_t> producerCount;
+    
+    std::atomic<size_t> initialBlockPoolIndex;
+    Block* initialBlockPool;
+    size_t initialBlockPoolSize;
+    
 #ifndef MCDBGQ_USEDEBUGFREELIST
-	FreeList<Block> freeList;
+    FreeList<Block> freeList;
 #else
-	debug::DebugFreeList<Block> freeList;
-#endif
-	
-	std::atomic<ImplicitProducerHash*> implicitProducerHash;
-	std::atomic<size_t> implicitProducerHashCount;		// Number of slots logically used
-	ImplicitProducerHash initialImplicitProducerHash;
-	std::array<ImplicitProducerKVP, INITIAL_IMPLICIT_PRODUCER_HASH_SIZE> initialImplicitProducerHashEntries;
-	std::atomic_flag implicitProducerHashResizeInProgress;
-	
-	std::atomic<std::uint32_t> nextExplicitConsumerId;
-	std::atomic<std::uint32_t> globalExplicitConsumerOffset;
-	
+    debug::DebugFreeList<Block> freeList;
+#endif
+    
+    std::atomic<ImplicitProducerHash*> implicitProducerHash;
+    std::atomic<size_t> implicitProducerHashCount;		// Number of slots logically used
+    ImplicitProducerHash initialImplicitProducerHash;
+    std::array<ImplicitProducerKVP, INITIAL_IMPLICIT_PRODUCER_HASH_SIZE> initialImplicitProducerHashEntries;
+    std::atomic_flag implicitProducerHashResizeInProgress;
+    
+    std::atomic<std::uint32_t> nextExplicitConsumerId;
+    std::atomic<std::uint32_t> globalExplicitConsumerOffset;
+    
 #ifdef MCDBGQ_NOLOCKFREE_IMPLICITPRODHASH
-	debug::DebugMutex implicitProdMutex;
+    debug::DebugMutex implicitProdMutex;
 #endif
-	
+    
 #ifdef MOODYCAMEL_QUEUE_INTERNAL_DEBUG
-	std::atomic<ExplicitProducer*> explicitProducers;
-	std::atomic<ImplicitProducer*> implicitProducers;
+    std::atomic<ExplicitProducer*> explicitProducers;
+    std::atomic<ImplicitProducer*> implicitProducers;
 #endif
 };
 
 
 template<typename T, typename Traits>
 ProducerToken::ProducerToken(ConcurrentQueue<T, Traits>& queue)
-	: producer(queue.recycle_or_create_producer(true))
+    : producer(queue.recycle_or_create_producer(true))
 {
-	if (producer != nullptr) {
-		producer->token = this;
-	}
+    if (producer != nullptr) {
+        producer->token = this;
+    }
 }
 
 template<typename T, typename Traits>
 ProducerToken::ProducerToken(BlockingConcurrentQueue<T, Traits>& queue)
-	: producer(reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->recycle_or_create_producer(true))
+    : producer(reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->recycle_or_create_producer(true))
 {
-	if (producer != nullptr) {
-		producer->token = this;
-	}
+    if (producer != nullptr) {
+        producer->token = this;
+    }
 }
 
 template<typename T, typename Traits>
 ConsumerToken::ConsumerToken(ConcurrentQueue<T, Traits>& queue)
-	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
+    : itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
 {
-	initialOffset = queue.nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
-	lastKnownGlobalOffset = static_cast<std::uint32_t>(-1);
+    initialOffset = queue.nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
+    lastKnownGlobalOffset = static_cast<std::uint32_t>(-1);
 }
 
 template<typename T, typename Traits>
 ConsumerToken::ConsumerToken(BlockingConcurrentQueue<T, Traits>& queue)
-	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
+    : itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
 {
-	initialOffset = reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
-	lastKnownGlobalOffset = static_cast<std::uint32_t>(-1);
+    initialOffset = reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
+    lastKnownGlobalOffset = static_cast<std::uint32_t>(-1);
 }
 
 template<typename T, typename Traits>
 inline void swap(ConcurrentQueue<T, Traits>& a, ConcurrentQueue<T, Traits>& b) MOODYCAMEL_NOEXCEPT
 {
-	a.swap(b);
+    a.swap(b);
 }
 
 inline void swap(ProducerToken& a, ProducerToken& b) MOODYCAMEL_NOEXCEPT
 {
-	a.swap(b);
+    a.swap(b);
 }
 
 inline void swap(ConsumerToken& a, ConsumerToken& b) MOODYCAMEL_NOEXCEPT
 {
-	a.swap(b);
+    a.swap(b);
 }
 
 template<typename T, typename Traits>
 inline void swap(typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& a, typename ConcurrentQueue<T, Traits>::ImplicitProducerKVP& b) MOODYCAMEL_NOEXCEPT
 {
-	a.swap(b);
+    a.swap(b);
 }
 
 }
diff --git a/Source/Base/Base/Math/HalfFloat.h b/Source/Base/Base/Math/HalfFloat.h
index 1c6ac9f5..3deb77b4 100644
--- a/Source/Base/Base/Math/HalfFloat.h
+++ b/Source/Base/Base/Math/HalfFloat.h
@@ -27,153 +27,153 @@
 
 //check C++11 language features
 #if defined(__clang__)										//clang
-	#if __has_feature(cxx_static_assert) && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)
-		#define HALF_ENABLE_CPP11_STATIC_ASSERT 1
-	#endif
-	#if __has_feature(cxx_constexpr) && !defined(HALF_ENABLE_CPP11_CONSTEXPR)
-		#define HALF_ENABLE_CPP11_CONSTEXPR 1
-	#endif
-	#if __has_feature(cxx_noexcept) && !defined(HALF_ENABLE_CPP11_NOEXCEPT)
-		#define HALF_ENABLE_CPP11_NOEXCEPT 1
-	#endif
-	#if __has_feature(cxx_user_literals) && !defined(HALF_ENABLE_CPP11_USER_LITERALS)
-		#define HALF_ENABLE_CPP11_USER_LITERALS 1
-	#endif
-	#if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L) && !defined(HALF_ENABLE_CPP11_LONG_LONG)
-		#define HALF_ENABLE_CPP11_LONG_LONG 1
-	#endif
+    #if __has_feature(cxx_static_assert) && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)
+        #define HALF_ENABLE_CPP11_STATIC_ASSERT 1
+    #endif
+    #if __has_feature(cxx_constexpr) && !defined(HALF_ENABLE_CPP11_CONSTEXPR)
+        #define HALF_ENABLE_CPP11_CONSTEXPR 1
+    #endif
+    #if __has_feature(cxx_noexcept) && !defined(HALF_ENABLE_CPP11_NOEXCEPT)
+        #define HALF_ENABLE_CPP11_NOEXCEPT 1
+    #endif
+    #if __has_feature(cxx_user_literals) && !defined(HALF_ENABLE_CPP11_USER_LITERALS)
+        #define HALF_ENABLE_CPP11_USER_LITERALS 1
+    #endif
+    #if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L) && !defined(HALF_ENABLE_CPP11_LONG_LONG)
+        #define HALF_ENABLE_CPP11_LONG_LONG 1
+    #endif
 /*#elif defined(__INTEL_COMPILER)								//Intel C++
-	#if __INTEL_COMPILER >= 1100 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)		????????
-		#define HALF_ENABLE_CPP11_STATIC_ASSERT 1
-	#endif
-	#if __INTEL_COMPILER >= 1300 && !defined(HALF_ENABLE_CPP11_CONSTEXPR)			????????
-		#define HALF_ENABLE_CPP11_CONSTEXPR 1
-	#endif
-	#if __INTEL_COMPILER >= 1300 && !defined(HALF_ENABLE_CPP11_NOEXCEPT)			????????
-		#define HALF_ENABLE_CPP11_NOEXCEPT 1
-	#endif
-	#if __INTEL_COMPILER >= 1100 && !defined(HALF_ENABLE_CPP11_LONG_LONG)			????????
-		#define HALF_ENABLE_CPP11_LONG_LONG 1
-	#endif*/
+    #if __INTEL_COMPILER >= 1100 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)		????????
+        #define HALF_ENABLE_CPP11_STATIC_ASSERT 1
+    #endif
+    #if __INTEL_COMPILER >= 1300 && !defined(HALF_ENABLE_CPP11_CONSTEXPR)			????????
+        #define HALF_ENABLE_CPP11_CONSTEXPR 1
+    #endif
+    #if __INTEL_COMPILER >= 1300 && !defined(HALF_ENABLE_CPP11_NOEXCEPT)			????????
+        #define HALF_ENABLE_CPP11_NOEXCEPT 1
+    #endif
+    #if __INTEL_COMPILER >= 1100 && !defined(HALF_ENABLE_CPP11_LONG_LONG)			????????
+        #define HALF_ENABLE_CPP11_LONG_LONG 1
+    #endif*/
 #elif defined(__GNUC__)										//gcc
-	#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
-		#if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)
-			#define HALF_ENABLE_CPP11_STATIC_ASSERT 1
-		#endif
-		#if HALF_GNUC_VERSION >= 406 && !defined(HALF_ENABLE_CPP11_CONSTEXPR)
-			#define HALF_ENABLE_CPP11_CONSTEXPR 1
-		#endif
-		#if HALF_GNUC_VERSION >= 406 && !defined(HALF_ENABLE_CPP11_NOEXCEPT)
-			#define HALF_ENABLE_CPP11_NOEXCEPT 1
-		#endif
-		#if HALF_GNUC_VERSION >= 407 && !defined(HALF_ENABLE_CPP11_USER_LITERALS)
-			#define HALF_ENABLE_CPP11_USER_LITERALS 1
-		#endif
-		#if !defined(HALF_ENABLE_CPP11_LONG_LONG)
-			#define HALF_ENABLE_CPP11_LONG_LONG 1
-		#endif
-	#endif
+    #if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
+        #if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)
+            #define HALF_ENABLE_CPP11_STATIC_ASSERT 1
+        #endif
+        #if HALF_GNUC_VERSION >= 406 && !defined(HALF_ENABLE_CPP11_CONSTEXPR)
+            #define HALF_ENABLE_CPP11_CONSTEXPR 1
+        #endif
+        #if HALF_GNUC_VERSION >= 406 && !defined(HALF_ENABLE_CPP11_NOEXCEPT)
+            #define HALF_ENABLE_CPP11_NOEXCEPT 1
+        #endif
+        #if HALF_GNUC_VERSION >= 407 && !defined(HALF_ENABLE_CPP11_USER_LITERALS)
+            #define HALF_ENABLE_CPP11_USER_LITERALS 1
+        #endif
+        #if !defined(HALF_ENABLE_CPP11_LONG_LONG)
+            #define HALF_ENABLE_CPP11_LONG_LONG 1
+        #endif
+    #endif
 #elif defined(_MSC_VER)										//Visual C++
-	#if _MSC_VER >= 1900 && !defined(HALF_ENABLE_CPP11_CONSTEXPR)
-		#define HALF_ENABLE_CPP11_CONSTEXPR 1
-	#endif
-	#if _MSC_VER >= 1900 && !defined(HALF_ENABLE_CPP11_NOEXCEPT)
-		#define HALF_ENABLE_CPP11_NOEXCEPT 1
-	#endif
-	#if _MSC_VER >= 1900 && !defined(HALF_ENABLE_CPP11_USER_LITERALS)
-		#define HALF_ENABLE_CPP11_USER_LITERALS 1
-	#endif
-	#if _MSC_VER >= 1600 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)
-		#define HALF_ENABLE_CPP11_STATIC_ASSERT 1
-	#endif
-	#if _MSC_VER >= 1310 && !defined(HALF_ENABLE_CPP11_LONG_LONG)
-		#define HALF_ENABLE_CPP11_LONG_LONG 1
-	#endif
-	#define HALF_POP_WARNINGS 1
-	#pragma warning(push)
-	#pragma warning(disable : 4099 4127 4146)	//struct vs class, constant in if, negative unsigned
+    #if _MSC_VER >= 1900 && !defined(HALF_ENABLE_CPP11_CONSTEXPR)
+        #define HALF_ENABLE_CPP11_CONSTEXPR 1
+    #endif
+    #if _MSC_VER >= 1900 && !defined(HALF_ENABLE_CPP11_NOEXCEPT)
+        #define HALF_ENABLE_CPP11_NOEXCEPT 1
+    #endif
+    #if _MSC_VER >= 1900 && !defined(HALF_ENABLE_CPP11_USER_LITERALS)
+        #define HALF_ENABLE_CPP11_USER_LITERALS 1
+    #endif
+    #if _MSC_VER >= 1600 && !defined(HALF_ENABLE_CPP11_STATIC_ASSERT)
+        #define HALF_ENABLE_CPP11_STATIC_ASSERT 1
+    #endif
+    #if _MSC_VER >= 1310 && !defined(HALF_ENABLE_CPP11_LONG_LONG)
+        #define HALF_ENABLE_CPP11_LONG_LONG 1
+    #endif
+    #define HALF_POP_WARNINGS 1
+    #pragma warning(push)
+    #pragma warning(disable : 4099 4127 4146)	//struct vs class, constant in if, negative unsigned
 #endif
 
 //check C++11 library features
 #include <utility>
 #if defined(_LIBCPP_VERSION)								//libc++
-	#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103
-		#ifndef HALF_ENABLE_CPP11_TYPE_TRAITS
-			#define HALF_ENABLE_CPP11_TYPE_TRAITS 1
-		#endif
-		#ifndef HALF_ENABLE_CPP11_CSTDINT
-			#define HALF_ENABLE_CPP11_CSTDINT 1
-		#endif
-		#ifndef HALF_ENABLE_CPP11_CMATH
-			#define HALF_ENABLE_CPP11_CMATH 1
-		#endif
-		#ifndef HALF_ENABLE_CPP11_HASH
-			#define HALF_ENABLE_CPP11_HASH 1
-		#endif
-	#endif
+    #if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103
+        #ifndef HALF_ENABLE_CPP11_TYPE_TRAITS
+            #define HALF_ENABLE_CPP11_TYPE_TRAITS 1
+        #endif
+        #ifndef HALF_ENABLE_CPP11_CSTDINT
+            #define HALF_ENABLE_CPP11_CSTDINT 1
+        #endif
+        #ifndef HALF_ENABLE_CPP11_CMATH
+            #define HALF_ENABLE_CPP11_CMATH 1
+        #endif
+        #ifndef HALF_ENABLE_CPP11_HASH
+            #define HALF_ENABLE_CPP11_HASH 1
+        #endif
+    #endif
 #elif defined(__GLIBCXX__)									//libstdc++
-	#if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103
-		#ifdef __clang__
-			#if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_TYPE_TRAITS)
-				#define HALF_ENABLE_CPP11_TYPE_TRAITS 1
-			#endif
-			#if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_CSTDINT)
-				#define HALF_ENABLE_CPP11_CSTDINT 1
-			#endif
-			#if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_CMATH)
-				#define HALF_ENABLE_CPP11_CMATH 1
-			#endif
-			#if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_HASH)
-				#define HALF_ENABLE_CPP11_HASH 1
-			#endif
-		#else
-			#if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_CSTDINT)
-				#define HALF_ENABLE_CPP11_CSTDINT 1
-			#endif
-			#if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_CMATH)
-				#define HALF_ENABLE_CPP11_CMATH 1
-			#endif
-			#if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_HASH)
-				#define HALF_ENABLE_CPP11_HASH 1
-			#endif
-		#endif
-	#endif
+    #if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103
+        #ifdef __clang__
+            #if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_TYPE_TRAITS)
+                #define HALF_ENABLE_CPP11_TYPE_TRAITS 1
+            #endif
+            #if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_CSTDINT)
+                #define HALF_ENABLE_CPP11_CSTDINT 1
+            #endif
+            #if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_CMATH)
+                #define HALF_ENABLE_CPP11_CMATH 1
+            #endif
+            #if __GLIBCXX__ >= 20080606 && !defined(HALF_ENABLE_CPP11_HASH)
+                #define HALF_ENABLE_CPP11_HASH 1
+            #endif
+        #else
+            #if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_CSTDINT)
+                #define HALF_ENABLE_CPP11_CSTDINT 1
+            #endif
+            #if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_CMATH)
+                #define HALF_ENABLE_CPP11_CMATH 1
+            #endif
+            #if HALF_GNUC_VERSION >= 403 && !defined(HALF_ENABLE_CPP11_HASH)
+                #define HALF_ENABLE_CPP11_HASH 1
+            #endif
+        #endif
+    #endif
 #elif defined(_CPPLIB_VER)									//Dinkumware/Visual C++
-	#if _CPPLIB_VER >= 520
-		#ifndef HALF_ENABLE_CPP11_TYPE_TRAITS
-			#define HALF_ENABLE_CPP11_TYPE_TRAITS 1
-		#endif
-		#ifndef HALF_ENABLE_CPP11_CSTDINT
-			#define HALF_ENABLE_CPP11_CSTDINT 1
-		#endif
-		#ifndef HALF_ENABLE_CPP11_HASH
-			#define HALF_ENABLE_CPP11_HASH 1
-		#endif
-	#endif
-	#if _CPPLIB_VER >= 610
-		#ifndef HALF_ENABLE_CPP11_CMATH
-			#define HALF_ENABLE_CPP11_CMATH 1
-		#endif
-	#endif
+    #if _CPPLIB_VER >= 520
+        #ifndef HALF_ENABLE_CPP11_TYPE_TRAITS
+            #define HALF_ENABLE_CPP11_TYPE_TRAITS 1
+        #endif
+        #ifndef HALF_ENABLE_CPP11_CSTDINT
+            #define HALF_ENABLE_CPP11_CSTDINT 1
+        #endif
+        #ifndef HALF_ENABLE_CPP11_HASH
+            #define HALF_ENABLE_CPP11_HASH 1
+        #endif
+    #endif
+    #if _CPPLIB_VER >= 610
+        #ifndef HALF_ENABLE_CPP11_CMATH
+            #define HALF_ENABLE_CPP11_CMATH 1
+        #endif
+    #endif
 #endif
 #undef HALF_GNUC_VERSION
 
 //support constexpr
 #if HALF_ENABLE_CPP11_CONSTEXPR
-	#define HALF_CONSTEXPR			constexpr
-	#define HALF_CONSTEXPR_CONST	constexpr
+    #define HALF_CONSTEXPR			constexpr
+    #define HALF_CONSTEXPR_CONST	constexpr
 #else
-	#define HALF_CONSTEXPR
-	#define HALF_CONSTEXPR_CONST	const
+    #define HALF_CONSTEXPR
+    #define HALF_CONSTEXPR_CONST	const
 #endif
 
 //support noexcept
 #if HALF_ENABLE_CPP11_NOEXCEPT
-	#define HALF_NOEXCEPT	noexcept
-	#define HALF_NOTHROW	noexcept
+    #define HALF_NOEXCEPT	noexcept
+    #define HALF_NOTHROW	noexcept
 #else
-	#define HALF_NOEXCEPT
-	#define HALF_NOTHROW	throw()
+    #define HALF_NOEXCEPT
+    #define HALF_NOTHROW	throw()
 #endif
 
 #include <algorithm>
@@ -184,13 +184,13 @@
 #include <cstring>
 #include <cstdlib>
 #if HALF_ENABLE_CPP11_TYPE_TRAITS
-	#include <type_traits>
+    #include <type_traits>
 #endif
 #if HALF_ENABLE_CPP11_CSTDINT
-	#include <cstdint>
+    #include <cstdint>
 #endif
 #if HALF_ENABLE_CPP11_HASH
-	#include <functional>
+    #include <functional>
 #endif
 
 
@@ -211,7 +211,7 @@
 /// set to infinity) and is the fastest rounding mode possible. It can even be set to `std::numeric_limits<float>::round_style` 
 /// to synchronize the rounding mode with that of the underlying single-precision implementation.
 #ifndef HALF_ROUND_STYLE
-	#define HALF_ROUND_STYLE	-1			// = std::round_indeterminate
+    #define HALF_ROUND_STYLE	-1			// = std::round_indeterminate
 #endif
 
 /// Tie-breaking behaviour for round to nearest.
@@ -220,7 +220,7 @@
 /// thus equal to the round() function), but can be redefined to `1` (before including half.hpp) if more IEEE-conformant 
 /// behaviour is needed.
 #ifndef HALF_ROUND_TIES_TO_EVEN
-	#define HALF_ROUND_TIES_TO_EVEN	0		// ties away from zero
+    #define HALF_ROUND_TIES_TO_EVEN	0		// ties away from zero
 #endif
 
 /// Value signaling overflow.
@@ -235,25 +235,25 @@
 #define FP_FAST_FMAH	1
 
 #ifndef FP_ILOGB0
-	#define FP_ILOGB0		INT_MIN
+    #define FP_ILOGB0		INT_MIN
 #endif
 #ifndef FP_ILOGBNAN
-	#define FP_ILOGBNAN		INT_MAX
+    #define FP_ILOGBNAN		INT_MAX
 #endif
 #ifndef FP_SUBNORMAL
-	#define FP_SUBNORMAL	0
+    #define FP_SUBNORMAL	0
 #endif
 #ifndef FP_ZERO
-	#define FP_ZERO			1
+    #define FP_ZERO			1
 #endif
 #ifndef FP_NAN
-	#define FP_NAN			2
+    #define FP_NAN			2
 #endif
 #ifndef FP_INFINITE
-	#define FP_INFINITE		3
+    #define FP_INFINITE		3
 #endif
 #ifndef FP_NORMAL
-	#define FP_NORMAL		4
+    #define FP_NORMAL		4
 #endif
 
 
@@ -261,2797 +261,2797 @@
 /// This namespace contains all the functionality provided by the library.
 namespace halffloat
 {
-	class half;
+    class half;
 
 #if HALF_ENABLE_CPP11_USER_LITERALS
-	/// Library-defined half-precision literals.
-	/// Import this namespace to enable half-precision floating point literals:
-	/// ~~~~{.cpp}
-	/// using namespace halffloat::literal;
-	/// halffloat::half = 4.2_h;
-	/// ~~~~
-	namespace literal
-	{
-		half operator""_h(long double);
-	}
+    /// Library-defined half-precision literals.
+    /// Import this namespace to enable half-precision floating point literals:
+    /// ~~~~{.cpp}
+    /// using namespace halffloat::literal;
+    /// halffloat::half = 4.2_h;
+    /// ~~~~
+    namespace literal
+    {
+        half operator""_h(long double);
+    }
 #endif
 
-	/// \internal
-	/// \brief Implementation details.
-	namespace detail
-	{
-	#if HALF_ENABLE_CPP11_TYPE_TRAITS
-		/// Conditional type.
-		template<bool B,typename T,typename F> struct conditional : std::conditional<B,T,F> {};
-
-		/// Helper for tag dispatching.
-		template<bool B> struct bool_type : std::integral_constant<bool,B> {};
-		using std::true_type;
-		using std::false_type;
-
-		/// Type traits for floating point types.
-		template<typename T> struct is_float : std::is_floating_point<T> {};
-	#else
-		/// Conditional type.
-		template<bool,typename T,typename> struct conditional { typedef T type; };
-		template<typename T,typename F> struct conditional<false,T,F> { typedef F type; };
-
-		/// Helper for tag dispatching.
-		template<bool> struct bool_type {};
-		typedef bool_type<true> true_type;
-		typedef bool_type<false> false_type;
-
-		/// Type traits for floating point types.
-		template<typename> struct is_float : false_type {};
-		template<typename T> struct is_float<const T> : is_float<T> {};
-		template<typename T> struct is_float<volatile T> : is_float<T> {};
-		template<typename T> struct is_float<const volatile T> : is_float<T> {};
-		template<> struct is_float<float> : true_type {};
-		template<> struct is_float<double> : true_type {};
-		template<> struct is_float<long double> : true_type {};
-	#endif
-
-		/// Type traits for floating point bits.
-		template<typename T> struct bits { typedef unsigned char type; };
-		template<typename T> struct bits<const T> : bits<T> {};
-		template<typename T> struct bits<volatile T> : bits<T> {};
-		template<typename T> struct bits<const volatile T> : bits<T> {};
-
-	#if HALF_ENABLE_CPP11_CSTDINT
-		/// Unsigned integer of (at least) 16 bits width.
-		typedef std::uint_least16_t uint16;
-
-		/// Unsigned integer of (at least) 32 bits width.
-		template<> struct bits<float> { typedef std::uint_least32_t type; };
-
-		/// Unsigned integer of (at least) 64 bits width.
-		template<> struct bits<double> { typedef std::uint_least64_t type; };
-	#else
-		/// Unsigned integer of (at least) 16 bits width.
-		typedef unsigned short uint16;
-
-		/// Unsigned integer of (at least) 32 bits width.
-		template<> struct bits<float> : conditional<std::numeric_limits<unsigned int>::digits>=32,unsigned int,unsigned long> {};
-
-		#if HALF_ENABLE_CPP11_LONG_LONG
-			/// Unsigned integer of (at least) 64 bits width.
-			template<> struct bits<double> : conditional<std::numeric_limits<unsigned long>::digits>=64,unsigned long,unsigned long long> {};
-		#else
-			/// Unsigned integer of (at least) 64 bits width.
-			template<> struct bits<double> { typedef unsigned long type; };
-		#endif
-	#endif
-
-		/// Tag type for binary construction.
-		struct binary_t {};
-
-		/// Tag for binary construction.
-		HALF_CONSTEXPR_CONST binary_t binary = binary_t();
-
-		/// Temporary half-precision expression.
-		/// This class represents a half-precision expression which just stores a single-precision value internally.
-		struct expr
-		{
-			/// Conversion constructor.
-			/// \param f single-precision value to convert
-			explicit HALF_CONSTEXPR expr(float f) HALF_NOEXCEPT : value_(f) {}
-
-			/// Conversion to single-precision.
-			/// \return single precision value representing expression value
-			HALF_CONSTEXPR operator float() const HALF_NOEXCEPT { return value_; }
-
-		private:
-			/// Internal expression value stored in single-precision.
-			float value_;
-		};
-
-		/// SFINAE helper for generic half-precision functions.
-		/// This class template has to be specialized for each valid combination of argument types to provide a corresponding 
-		/// `type` member equivalent to \a T.
-		/// \tparam T type to return
-		template<typename T,typename,typename=void,typename=void> struct enable {};
-		template<typename T> struct enable<T,half,void,void> { typedef T type; };
-		template<typename T> struct enable<T,expr,void,void> { typedef T type; };
-		template<typename T> struct enable<T,half,half,void> { typedef T type; };
-		template<typename T> struct enable<T,half,expr,void> { typedef T type; };
-		template<typename T> struct enable<T,expr,half,void> { typedef T type; };
-		template<typename T> struct enable<T,expr,expr,void> { typedef T type; };
-		template<typename T> struct enable<T,half,half,half> { typedef T type; };
-		template<typename T> struct enable<T,half,half,expr> { typedef T type; };
-		template<typename T> struct enable<T,half,expr,half> { typedef T type; };
-		template<typename T> struct enable<T,half,expr,expr> { typedef T type; };
-		template<typename T> struct enable<T,expr,half,half> { typedef T type; };
-		template<typename T> struct enable<T,expr,half,expr> { typedef T type; };
-		template<typename T> struct enable<T,expr,expr,half> { typedef T type; };
-		template<typename T> struct enable<T,expr,expr,expr> { typedef T type; };
-
-		/// Return type for specialized generic 2-argument half-precision functions.
-		/// This class template has to be specialized for each valid combination of argument types to provide a corresponding 
-		/// `type` member denoting the appropriate return type.
-		/// \tparam T first argument type
-		/// \tparam U first argument type
-		template<typename T,typename U> struct result : enable<expr,T,U> {};
-		template<> struct result<half,half> { typedef half type; };
-
-		/// \name Classification helpers
-		/// \{
-
-		/// Check for infinity.
-		/// \tparam T argument type (builtin floating point type)
-		/// \param arg value to query
-		/// \retval true if infinity
-		/// \retval false else
-		template<typename T> bool builtin_isinf(T arg)
-		{
-		#if HALF_ENABLE_CPP11_CMATH
-			return std::isinf(arg);
-		#elif defined(_MSC_VER)
-			return !::_finite(static_cast<double>(arg)) && !::_isnan(static_cast<double>(arg));
-		#else
-			return arg == std::numeric_limits<T>::infinity() || arg == -std::numeric_limits<T>::infinity();
-		#endif
-		}
-
-		/// Check for NaN.
-		/// \tparam T argument type (builtin floating point type)
-		/// \param arg value to query
-		/// \retval true if not a number
-		/// \retval false else
-		template<typename T> bool builtin_isnan(T arg)
-		{
-		#if HALF_ENABLE_CPP11_CMATH
-			return std::isnan(arg);
-		#elif defined(_MSC_VER)
-			return ::_isnan(static_cast<double>(arg)) != 0;
-		#else
-			return arg != arg;
-		#endif
-		}
-
-		/// Check sign.
-		/// \tparam T argument type (builtin floating point type)
-		/// \param arg value to query
-		/// \retval true if signbit set
-		/// \retval false else
-		template<typename T> bool builtin_signbit(T arg)
-		{
-		#if HALF_ENABLE_CPP11_CMATH
-			return std::signbit(arg);
-		#else
-			return arg < T() || (arg == T() && T(1)/arg < T());
-		#endif
-		}
-
-		/// \}
-		/// \name Conversion
-		/// \{
-
-		/// Convert IEEE single-precision to half-precision.
-		/// Credit for this goes to [Jeroen van der Zijp](ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf).
-		/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
-		/// \param value single-precision value
-		/// \return binary representation of half-precision value
-		template<std::float_round_style R> uint16 float2half_impl(float value, true_type)
-		{
-			typedef bits<float>::type uint32;
-			uint32 bits;// = *reinterpret_cast<uint32*>(&value);		//violating strict aliasing!
-			std::memcpy(&bits, &value, sizeof(float));
+    /// \internal
+    /// \brief Implementation details.
+    namespace detail
+    {
+    #if HALF_ENABLE_CPP11_TYPE_TRAITS
+        /// Conditional type.
+        template<bool B,typename T,typename F> struct conditional : std::conditional<B,T,F> {};
+
+        /// Helper for tag dispatching.
+        template<bool B> struct bool_type : std::integral_constant<bool,B> {};
+        using std::true_type;
+        using std::false_type;
+
+        /// Type traits for floating point types.
+        template<typename T> struct is_float : std::is_floating_point<T> {};
+    #else
+        /// Conditional type.
+        template<bool,typename T,typename> struct conditional { typedef T type; };
+        template<typename T,typename F> struct conditional<false,T,F> { typedef F type; };
+
+        /// Helper for tag dispatching.
+        template<bool> struct bool_type {};
+        typedef bool_type<true> true_type;
+        typedef bool_type<false> false_type;
+
+        /// Type traits for floating point types.
+        template<typename> struct is_float : false_type {};
+        template<typename T> struct is_float<const T> : is_float<T> {};
+        template<typename T> struct is_float<volatile T> : is_float<T> {};
+        template<typename T> struct is_float<const volatile T> : is_float<T> {};
+        template<> struct is_float<float> : true_type {};
+        template<> struct is_float<double> : true_type {};
+        template<> struct is_float<long double> : true_type {};
+    #endif
+
+        /// Type traits for floating point bits.
+        template<typename T> struct bits { typedef unsigned char type; };
+        template<typename T> struct bits<const T> : bits<T> {};
+        template<typename T> struct bits<volatile T> : bits<T> {};
+        template<typename T> struct bits<const volatile T> : bits<T> {};
+
+    #if HALF_ENABLE_CPP11_CSTDINT
+        /// Unsigned integer of (at least) 16 bits width.
+        typedef std::uint_least16_t uint16;
+
+        /// Unsigned integer of (at least) 32 bits width.
+        template<> struct bits<float> { typedef std::uint_least32_t type; };
+
+        /// Unsigned integer of (at least) 64 bits width.
+        template<> struct bits<double> { typedef std::uint_least64_t type; };
+    #else
+        /// Unsigned integer of (at least) 16 bits width.
+        typedef unsigned short uint16;
+
+        /// Unsigned integer of (at least) 32 bits width.
+        template<> struct bits<float> : conditional<std::numeric_limits<unsigned int>::digits>=32,unsigned int,unsigned long> {};
+
+        #if HALF_ENABLE_CPP11_LONG_LONG
+            /// Unsigned integer of (at least) 64 bits width.
+            template<> struct bits<double> : conditional<std::numeric_limits<unsigned long>::digits>=64,unsigned long,unsigned long long> {};
+        #else
+            /// Unsigned integer of (at least) 64 bits width.
+            template<> struct bits<double> { typedef unsigned long type; };
+        #endif
+    #endif
+
+        /// Tag type for binary construction.
+        struct binary_t {};
+
+        /// Tag for binary construction.
+        HALF_CONSTEXPR_CONST binary_t binary = binary_t();
+
+        /// Temporary half-precision expression.
+        /// This class represents a half-precision expression which just stores a single-precision value internally.
+        struct expr
+        {
+            /// Conversion constructor.
+            /// \param f single-precision value to convert
+            explicit HALF_CONSTEXPR expr(float f) HALF_NOEXCEPT : value_(f) {}
+
+            /// Conversion to single-precision.
+            /// \return single precision value representing expression value
+            HALF_CONSTEXPR operator float() const HALF_NOEXCEPT { return value_; }
+
+        private:
+            /// Internal expression value stored in single-precision.
+            float value_;
+        };
+
+        /// SFINAE helper for generic half-precision functions.
+        /// This class template has to be specialized for each valid combination of argument types to provide a corresponding 
+        /// `type` member equivalent to \a T.
+        /// \tparam T type to return
+        template<typename T,typename,typename=void,typename=void> struct enable {};
+        template<typename T> struct enable<T,half,void,void> { typedef T type; };
+        template<typename T> struct enable<T,expr,void,void> { typedef T type; };
+        template<typename T> struct enable<T,half,half,void> { typedef T type; };
+        template<typename T> struct enable<T,half,expr,void> { typedef T type; };
+        template<typename T> struct enable<T,expr,half,void> { typedef T type; };
+        template<typename T> struct enable<T,expr,expr,void> { typedef T type; };
+        template<typename T> struct enable<T,half,half,half> { typedef T type; };
+        template<typename T> struct enable<T,half,half,expr> { typedef T type; };
+        template<typename T> struct enable<T,half,expr,half> { typedef T type; };
+        template<typename T> struct enable<T,half,expr,expr> { typedef T type; };
+        template<typename T> struct enable<T,expr,half,half> { typedef T type; };
+        template<typename T> struct enable<T,expr,half,expr> { typedef T type; };
+        template<typename T> struct enable<T,expr,expr,half> { typedef T type; };
+        template<typename T> struct enable<T,expr,expr,expr> { typedef T type; };
+
+        /// Return type for specialized generic 2-argument half-precision functions.
+        /// This class template has to be specialized for each valid combination of argument types to provide a corresponding 
+        /// `type` member denoting the appropriate return type.
+        /// \tparam T first argument type
+        /// \tparam U first argument type
+        template<typename T,typename U> struct result : enable<expr,T,U> {};
+        template<> struct result<half,half> { typedef half type; };
+
+        /// \name Classification helpers
+        /// \{
+
+        /// Check for infinity.
+        /// \tparam T argument type (builtin floating point type)
+        /// \param arg value to query
+        /// \retval true if infinity
+        /// \retval false else
+        template<typename T> bool builtin_isinf(T arg)
+        {
+        #if HALF_ENABLE_CPP11_CMATH
+            return std::isinf(arg);
+        #elif defined(_MSC_VER)
+            return !::_finite(static_cast<double>(arg)) && !::_isnan(static_cast<double>(arg));
+        #else
+            return arg == std::numeric_limits<T>::infinity() || arg == -std::numeric_limits<T>::infinity();
+        #endif
+        }
+
+        /// Check for NaN.
+        /// \tparam T argument type (builtin floating point type)
+        /// \param arg value to query
+        /// \retval true if not a number
+        /// \retval false else
+        template<typename T> bool builtin_isnan(T arg)
+        {
+        #if HALF_ENABLE_CPP11_CMATH
+            return std::isnan(arg);
+        #elif defined(_MSC_VER)
+            return ::_isnan(static_cast<double>(arg)) != 0;
+        #else
+            return arg != arg;
+        #endif
+        }
+
+        /// Check sign.
+        /// \tparam T argument type (builtin floating point type)
+        /// \param arg value to query
+        /// \retval true if signbit set
+        /// \retval false else
+        template<typename T> bool builtin_signbit(T arg)
+        {
+        #if HALF_ENABLE_CPP11_CMATH
+            return std::signbit(arg);
+        #else
+            return arg < T() || (arg == T() && T(1)/arg < T());
+        #endif
+        }
+
+        /// \}
+        /// \name Conversion
+        /// \{
+
+        /// Convert IEEE single-precision to half-precision.
+        /// Credit for this goes to [Jeroen van der Zijp](ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf).
+        /// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
+        /// \param value single-precision value
+        /// \return binary representation of half-precision value
+        template<std::float_round_style R> uint16 float2half_impl(float value, true_type)
+        {
+            typedef bits<float>::type uint32;
+            uint32 bits;// = *reinterpret_cast<uint32*>(&value);		//violating strict aliasing!
+            std::memcpy(&bits, &value, sizeof(float));
 /*			uint16 hbits = (bits>>16) & 0x8000;
-			bits &= 0x7FFFFFFF;
-			int exp = bits >> 23;
-			if(exp == 255)
-				return hbits | 0x7C00 | (0x3FF&-static_cast<unsigned>((bits&0x7FFFFF)!=0));
-			if(exp > 142)
-			{
-				if(R == std::round_toward_infinity)
-					return hbits | 0x7C00 - (hbits>>15);
-				if(R == std::round_toward_neg_infinity)
-					return hbits | 0x7BFF + (hbits>>15);
-				return hbits | 0x7BFF + (R!=std::round_toward_zero);
-			}
-			int g, s;
-			if(exp > 112)
-			{
-				g = (bits>>12) & 1;
-				s = (bits&0xFFF) != 0;
-				hbits |= ((exp-112)<<10) | ((bits>>13)&0x3FF);
-			}
-			else if(exp > 101)
-			{
-				int i = 125 - exp;
-				bits = (bits&0x7FFFFF) | 0x800000;
-				g = (bits>>i) & 1;
-				s = (bits&((1L<<i)-1)) != 0;
-				hbits |= bits >> (i+1);
-			}
-			else
-			{
-				g = 0;
-				s = bits != 0;
-			}
-			if(R == std::round_to_nearest)
-				#if HALF_ROUND_TIES_TO_EVEN
-					hbits += g & (s|hbits);
-				#else
-					hbits += g;
-				#endif
-			else if(R == std::round_toward_infinity)
-				hbits += ~(hbits>>15) & (s|g);
-			else if(R == std::round_toward_neg_infinity)
-				hbits += (hbits>>15) & (g|s);
+            bits &= 0x7FFFFFFF;
+            int exp = bits >> 23;
+            if(exp == 255)
+                return hbits | 0x7C00 | (0x3FF&-static_cast<unsigned>((bits&0x7FFFFF)!=0));
+            if(exp > 142)
+            {
+                if(R == std::round_toward_infinity)
+                    return hbits | 0x7C00 - (hbits>>15);
+                if(R == std::round_toward_neg_infinity)
+                    return hbits | 0x7BFF + (hbits>>15);
+                return hbits | 0x7BFF + (R!=std::round_toward_zero);
+            }
+            int g, s;
+            if(exp > 112)
+            {
+                g = (bits>>12) & 1;
+                s = (bits&0xFFF) != 0;
+                hbits |= ((exp-112)<<10) | ((bits>>13)&0x3FF);
+            }
+            else if(exp > 101)
+            {
+                int i = 125 - exp;
+                bits = (bits&0x7FFFFF) | 0x800000;
+                g = (bits>>i) & 1;
+                s = (bits&((1L<<i)-1)) != 0;
+                hbits |= bits >> (i+1);
+            }
+            else
+            {
+                g = 0;
+                s = bits != 0;
+            }
+            if(R == std::round_to_nearest)
+                #if HALF_ROUND_TIES_TO_EVEN
+                    hbits += g & (s|hbits);
+                #else
+                    hbits += g;
+                #endif
+            else if(R == std::round_toward_infinity)
+                hbits += ~(hbits>>15) & (s|g);
+            else if(R == std::round_toward_neg_infinity)
+                hbits += (hbits>>15) & (g|s);
 */			static const uint16 base_table[512] = { 
-				0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
-				0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
-				0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
-				0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
-				0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
-				0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
-				0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 
-				0x0200, 0x0400, 0x0800, 0x0C00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x2400, 0x2800, 0x2C00, 0x3000, 0x3400, 0x3800, 0x3C00, 
-				0x4000, 0x4400, 0x4800, 0x4C00, 0x5000, 0x5400, 0x5800, 0x5C00, 0x6000, 0x6400, 0x6800, 0x6C00, 0x7000, 0x7400, 0x7800, 0x7C00, 
-				0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
-				0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
-				0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
-				0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
-				0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
-				0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
-				0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
-				0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
-				0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
-				0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
-				0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
-				0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
-				0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
-				0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8002, 0x8004, 0x8008, 0x8010, 0x8020, 0x8040, 0x8080, 0x8100, 
-				0x8200, 0x8400, 0x8800, 0x8C00, 0x9000, 0x9400, 0x9800, 0x9C00, 0xA000, 0xA400, 0xA800, 0xAC00, 0xB000, 0xB400, 0xB800, 0xBC00, 
-				0xC000, 0xC400, 0xC800, 0xCC00, 0xD000, 0xD400, 0xD800, 0xDC00, 0xE000, 0xE400, 0xE800, 0xEC00, 0xF000, 0xF400, 0xF800, 0xFC00, 
-				0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
-				0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
-				0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
-				0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
-				0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
-				0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
-				0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00 };
-			static const unsigned char shift_table[512] = { 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
-				13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 13, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
-				13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
-				24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 13 };
-			uint16 hbits = base_table[bits>>23] + static_cast<uint16>((bits&0x7FFFFF)>>shift_table[bits>>23]);
-			if(R == std::round_to_nearest)
-				hbits += (((bits&0x7FFFFF)>>(shift_table[bits>>23]-1))|(((bits>>23)&0xFF)==102)) & ((hbits&0x7C00)!=0x7C00)
-				#if HALF_ROUND_TIES_TO_EVEN
-					& (((((static_cast<uint32>(1)<<(shift_table[bits>>23]-1))-1)&bits)!=0)|hbits)
-				#endif
-				;
-			else if(R == std::round_toward_zero)
-				hbits -= ((hbits&0x7FFF)==0x7C00) & ~shift_table[bits>>23];
-			else if(R == std::round_toward_infinity)
-				hbits += ((((bits&0x7FFFFF&((static_cast<uint32>(1)<<(shift_table[bits>>23]))-1))!=0)|(((bits>>23)<=102)&
-					((bits>>23)!=0)))&(hbits<0x7C00)) - ((hbits==0xFC00)&((bits>>23)!=511));
-			else if(R == std::round_toward_neg_infinity)
-				hbits += ((((bits&0x7FFFFF&((static_cast<uint32>(1)<<(shift_table[bits>>23]))-1))!=0)|(((bits>>23)<=358)&
-					((bits>>23)!=256)))&(hbits<0xFC00)&(hbits>>15)) - ((hbits==0x7C00)&((bits>>23)!=255));
-			return hbits;
-		}
-
-		/// Convert IEEE double-precision to half-precision.
-		/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
-		/// \param value double-precision value
-		/// \return binary representation of half-precision value
-		template<std::float_round_style R> uint16 float2half_impl(double value, true_type)
-		{
-			typedef bits<float>::type uint32;
-			typedef bits<double>::type uint64;
-			uint64 bits;// = *reinterpret_cast<uint64*>(&value);		//violating strict aliasing!
-			std::memcpy(&bits, &value, sizeof(double));
-			uint32 hi = bits >> 32, lo = bits & 0xFFFFFFFF;
-			uint16 hbits = (hi>>16) & 0x8000;
-			hi &= 0x7FFFFFFF;
-			int exp = hi >> 20;
-			if(exp == 2047)
-				return hbits | 0x7C00 | (0x3FF&-static_cast<unsigned>((bits&0xFFFFFFFFFFFFF)!=0));
-			if(exp > 1038)
-			{
-				if(R == std::round_toward_infinity)
-					return hbits | 0x7C00 - (hbits>>15);
-				if(R == std::round_toward_neg_infinity)
-					return hbits | 0x7BFF + (hbits>>15);
-				return hbits | 0x7BFF + (R!=std::round_toward_zero);
-			}
-			int g, s = lo != 0;
-			if(exp > 1008)
-			{
-				g = (hi>>9) & 1;
-				s |= (hi&0x1FF) != 0;
-				hbits |= ((exp-1008)<<10) | ((hi>>10)&0x3FF);
-			}
-			else if(exp > 997)
-			{
-				int i = 1018 - exp;
-				hi = (hi&0xFFFFF) | 0x100000;
-				g = (hi>>i) & 1;
-				s |= (hi&((1L<<i)-1)) != 0;
-				hbits |= hi >> (i+1);
-			}
-			else
-			{
-				g = 0;
-				s |= hi != 0;
-			}
-			if(R == std::round_to_nearest)
-				#if HALF_ROUND_TIES_TO_EVEN
-					hbits += g & (s|hbits);
-				#else
-					hbits += g;
-				#endif
-			else if(R == std::round_toward_infinity)
-				hbits += ~(hbits>>15) & (s|g);
-			else if(R == std::round_toward_neg_infinity)
-				hbits += (hbits>>15) & (g|s);
-			return hbits;
-		}
-
-		/// Convert non-IEEE floating point to half-precision.
-		/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
-		/// \tparam T source type (builtin floating point type)
-		/// \param value floating point value
-		/// \return binary representation of half-precision value
-		template<std::float_round_style R,typename T> uint16 float2half_impl(T value, ...)
-		{
-			uint16 hbits = static_cast<unsigned>(builtin_signbit(value)) << 15;
-			if(value == T())
-				return hbits;
-			if(builtin_isnan(value))
-				return hbits | 0x7FFF;
-			if(builtin_isinf(value))
-				return hbits | 0x7C00;
-			int exp;
-			std::frexp(value, &exp);
-			if(exp > 16)
-			{
-				if(R == std::round_toward_infinity)
-					return hbits | (0x7C00-(hbits>>15));
-				else if(R == std::round_toward_neg_infinity)
-					return hbits | (0x7BFF+(hbits>>15));
-				return hbits | (0x7BFF+(R!=std::round_toward_zero));
-			}
-			if(exp < -13)
-				value = std::ldexp(value, 24);
-			else
-			{
-				value = std::ldexp(value, 11-exp);
-				hbits |= ((exp+13)<<10);
-			}
-			T ival, frac = std::modf(value, &ival);
-			hbits += static_cast<uint16>(std::abs(static_cast<int>(ival)));
-			if(R == std::round_to_nearest)
-			{
-				frac = std::abs(frac);
-				#if HALF_ROUND_TIES_TO_EVEN
-					hbits += (frac>T(0.5)) | ((frac==T(0.5))&hbits);
-				#else
-					hbits += frac >= T(0.5);
-				#endif
-			}
-			else if(R == std::round_toward_infinity)
-				hbits += frac > T();
-			else if(R == std::round_toward_neg_infinity)
-				hbits += frac < T();
-			return hbits;
-		}
-
-		/// Convert floating point to half-precision.
-		/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
-		/// \tparam T source type (builtin floating point type)
-		/// \param value floating point value
-		/// \return binary representation of half-precision value
-		template<std::float_round_style R,typename T> uint16 float2half(T value)
-		{
-			return float2half_impl<R>(value, bool_type<std::numeric_limits<T>::is_iec559&&sizeof(typename bits<T>::type)==sizeof(T)>());
-		}
-
-		/// Convert integer to half-precision floating point.
-		/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
-		/// \tparam S `true` if value negative, `false` else
-		/// \tparam T type to convert (builtin integer type)
-		/// \param value non-negative integral value
-		/// \return binary representation of half-precision value
-		template<std::float_round_style R,bool S,typename T> uint16 int2half_impl(T value)
-		{
-		#if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
-			static_assert(std::is_integral<T>::value, "int to half conversion only supports builtin integer types");
-		#endif
-			if(S)
-				value = -value;
-			uint16 bits = S << 15;
-			if(value > 0xFFFF)
-			{
-				if(R == std::round_toward_infinity)
-					bits |= 0x7C00 - S;
-				else if(R == std::round_toward_neg_infinity)
-					bits |= 0x7BFF + S;
-				else
-					bits |= 0x7BFF + (R!=std::round_toward_zero);
-			}
-			else if(value)
-			{
-				unsigned int m = value, exp = 24;
-				for(; m<0x400; m<<=1,--exp) ;
-				for(; m>0x7FF; m>>=1,++exp) ;
-				bits |= (exp<<10) + m;
-				if(exp > 24)
-				{
-					if(R == std::round_to_nearest)
-						bits += (value>>(exp-25)) & 1
-						#if HALF_ROUND_TIES_TO_EVEN
-							& (((((1<<(exp-25))-1)&value)!=0)|bits)
-						#endif
-						;
-					else if(R == std::round_toward_infinity)
-						bits += ((value&((1<<(exp-24))-1))!=0) & !S;
-					else if(R == std::round_toward_neg_infinity)
-						bits += ((value&((1<<(exp-24))-1))!=0) & S;
-				}
-			}
-			return bits;
-		}
-
-		/// Convert integer to half-precision floating point.
-		/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
-		/// \tparam T type to convert (builtin integer type)
-		/// \param value integral value
-		/// \return binary representation of half-precision value
-		template<std::float_round_style R,typename T> uint16 int2half(T value)
-		{
-			return (value<0) ? int2half_impl<R,true>(value) : int2half_impl<R,false>(value);
-		}
-
-		/// Convert half-precision to IEEE single-precision.
-		/// Credit for this goes to [Jeroen van der Zijp](ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf).
-		/// \param value binary representation of half-precision value
-		/// \return single-precision value
-		inline float half2float_impl(uint16 value, float, true_type)
-		{
-			typedef bits<float>::type uint32;
+                0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+                0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+                0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+                0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+                0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+                0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 
+                0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080, 0x0100, 
+                0x0200, 0x0400, 0x0800, 0x0C00, 0x1000, 0x1400, 0x1800, 0x1C00, 0x2000, 0x2400, 0x2800, 0x2C00, 0x3000, 0x3400, 0x3800, 0x3C00, 
+                0x4000, 0x4400, 0x4800, 0x4C00, 0x5000, 0x5400, 0x5800, 0x5C00, 0x6000, 0x6400, 0x6800, 0x6C00, 0x7000, 0x7400, 0x7800, 0x7C00, 
+                0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
+                0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
+                0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
+                0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
+                0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
+                0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
+                0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 0x7C00, 
+                0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
+                0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
+                0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
+                0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
+                0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
+                0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 
+                0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8000, 0x8001, 0x8002, 0x8004, 0x8008, 0x8010, 0x8020, 0x8040, 0x8080, 0x8100, 
+                0x8200, 0x8400, 0x8800, 0x8C00, 0x9000, 0x9400, 0x9800, 0x9C00, 0xA000, 0xA400, 0xA800, 0xAC00, 0xB000, 0xB400, 0xB800, 0xBC00, 
+                0xC000, 0xC400, 0xC800, 0xCC00, 0xD000, 0xD400, 0xD800, 0xDC00, 0xE000, 0xE400, 0xE800, 0xEC00, 0xF000, 0xF400, 0xF800, 0xFC00, 
+                0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
+                0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
+                0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
+                0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
+                0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
+                0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 
+                0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00, 0xFC00 };
+            static const unsigned char shift_table[512] = { 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+                13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 13, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 
+                13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 13 };
+            uint16 hbits = base_table[bits>>23] + static_cast<uint16>((bits&0x7FFFFF)>>shift_table[bits>>23]);
+            if(R == std::round_to_nearest)
+                hbits += (((bits&0x7FFFFF)>>(shift_table[bits>>23]-1))|(((bits>>23)&0xFF)==102)) & ((hbits&0x7C00)!=0x7C00)
+                #if HALF_ROUND_TIES_TO_EVEN
+                    & (((((static_cast<uint32>(1)<<(shift_table[bits>>23]-1))-1)&bits)!=0)|hbits)
+                #endif
+                ;
+            else if(R == std::round_toward_zero)
+                hbits -= ((hbits&0x7FFF)==0x7C00) & ~shift_table[bits>>23];
+            else if(R == std::round_toward_infinity)
+                hbits += ((((bits&0x7FFFFF&((static_cast<uint32>(1)<<(shift_table[bits>>23]))-1))!=0)|(((bits>>23)<=102)&
+                    ((bits>>23)!=0)))&(hbits<0x7C00)) - ((hbits==0xFC00)&((bits>>23)!=511));
+            else if(R == std::round_toward_neg_infinity)
+                hbits += ((((bits&0x7FFFFF&((static_cast<uint32>(1)<<(shift_table[bits>>23]))-1))!=0)|(((bits>>23)<=358)&
+                    ((bits>>23)!=256)))&(hbits<0xFC00)&(hbits>>15)) - ((hbits==0x7C00)&((bits>>23)!=255));
+            return hbits;
+        }
+
+        /// Convert IEEE double-precision to half-precision.
+        /// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
+        /// \param value double-precision value
+        /// \return binary representation of half-precision value
+        template<std::float_round_style R> uint16 float2half_impl(double value, true_type)
+        {
+            typedef bits<float>::type uint32;
+            typedef bits<double>::type uint64;
+            uint64 bits;// = *reinterpret_cast<uint64*>(&value);		//violating strict aliasing!
+            std::memcpy(&bits, &value, sizeof(double));
+            uint32 hi = bits >> 32, lo = bits & 0xFFFFFFFF;
+            uint16 hbits = (hi>>16) & 0x8000;
+            hi &= 0x7FFFFFFF;
+            int exp = hi >> 20;
+            if(exp == 2047)
+                return hbits | 0x7C00 | (0x3FF&-static_cast<unsigned>((bits&0xFFFFFFFFFFFFF)!=0));
+            if(exp > 1038)
+            {
+                if(R == std::round_toward_infinity)
+                    return hbits | 0x7C00 - (hbits>>15);
+                if(R == std::round_toward_neg_infinity)
+                    return hbits | 0x7BFF + (hbits>>15);
+                return hbits | 0x7BFF + (R!=std::round_toward_zero);
+            }
+            int g, s = lo != 0;
+            if(exp > 1008)
+            {
+                g = (hi>>9) & 1;
+                s |= (hi&0x1FF) != 0;
+                hbits |= ((exp-1008)<<10) | ((hi>>10)&0x3FF);
+            }
+            else if(exp > 997)
+            {
+                int i = 1018 - exp;
+                hi = (hi&0xFFFFF) | 0x100000;
+                g = (hi>>i) & 1;
+                s |= (hi&((1L<<i)-1)) != 0;
+                hbits |= hi >> (i+1);
+            }
+            else
+            {
+                g = 0;
+                s |= hi != 0;
+            }
+            if(R == std::round_to_nearest)
+                #if HALF_ROUND_TIES_TO_EVEN
+                    hbits += g & (s|hbits);
+                #else
+                    hbits += g;
+                #endif
+            else if(R == std::round_toward_infinity)
+                hbits += ~(hbits>>15) & (s|g);
+            else if(R == std::round_toward_neg_infinity)
+                hbits += (hbits>>15) & (g|s);
+            return hbits;
+        }
+
+        /// Convert non-IEEE floating point to half-precision.
+        /// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
+        /// \tparam T source type (builtin floating point type)
+        /// \param value floating point value
+        /// \return binary representation of half-precision value
+        template<std::float_round_style R,typename T> uint16 float2half_impl(T value, ...)
+        {
+            uint16 hbits = static_cast<unsigned>(builtin_signbit(value)) << 15;
+            if(value == T())
+                return hbits;
+            if(builtin_isnan(value))
+                return hbits | 0x7FFF;
+            if(builtin_isinf(value))
+                return hbits | 0x7C00;
+            int exp;
+            std::frexp(value, &exp);
+            if(exp > 16)
+            {
+                if(R == std::round_toward_infinity)
+                    return hbits | (0x7C00-(hbits>>15));
+                else if(R == std::round_toward_neg_infinity)
+                    return hbits | (0x7BFF+(hbits>>15));
+                return hbits | (0x7BFF+(R!=std::round_toward_zero));
+            }
+            if(exp < -13)
+                value = std::ldexp(value, 24);
+            else
+            {
+                value = std::ldexp(value, 11-exp);
+                hbits |= ((exp+13)<<10);
+            }
+            T ival, frac = std::modf(value, &ival);
+            hbits += static_cast<uint16>(std::abs(static_cast<int>(ival)));
+            if(R == std::round_to_nearest)
+            {
+                frac = std::abs(frac);
+                #if HALF_ROUND_TIES_TO_EVEN
+                    hbits += (frac>T(0.5)) | ((frac==T(0.5))&hbits);
+                #else
+                    hbits += frac >= T(0.5);
+                #endif
+            }
+            else if(R == std::round_toward_infinity)
+                hbits += frac > T();
+            else if(R == std::round_toward_neg_infinity)
+                hbits += frac < T();
+            return hbits;
+        }
+
+        /// Convert floating point to half-precision.
+        /// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
+        /// \tparam T source type (builtin floating point type)
+        /// \param value floating point value
+        /// \return binary representation of half-precision value
+        template<std::float_round_style R,typename T> uint16 float2half(T value)
+        {
+            return float2half_impl<R>(value, bool_type<std::numeric_limits<T>::is_iec559&&sizeof(typename bits<T>::type)==sizeof(T)>());
+        }
+
+        /// Convert integer to half-precision floating point.
+        /// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
+        /// \tparam S `true` if value negative, `false` else
+        /// \tparam T type to convert (builtin integer type)
+        /// \param value non-negative integral value
+        /// \return binary representation of half-precision value
+        template<std::float_round_style R,bool S,typename T> uint16 int2half_impl(T value)
+        {
+        #if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
+            static_assert(std::is_integral<T>::value, "int to half conversion only supports builtin integer types");
+        #endif
+            if(S)
+                value = -value;
+            uint16 bits = S << 15;
+            if(value > 0xFFFF)
+            {
+                if(R == std::round_toward_infinity)
+                    bits |= 0x7C00 - S;
+                else if(R == std::round_toward_neg_infinity)
+                    bits |= 0x7BFF + S;
+                else
+                    bits |= 0x7BFF + (R!=std::round_toward_zero);
+            }
+            else if(value)
+            {
+                unsigned int m = value, exp = 24;
+                for(; m<0x400; m<<=1,--exp) ;
+                for(; m>0x7FF; m>>=1,++exp) ;
+                bits |= (exp<<10) + m;
+                if(exp > 24)
+                {
+                    if(R == std::round_to_nearest)
+                        bits += (value>>(exp-25)) & 1
+                        #if HALF_ROUND_TIES_TO_EVEN
+                            & (((((1<<(exp-25))-1)&value)!=0)|bits)
+                        #endif
+                        ;
+                    else if(R == std::round_toward_infinity)
+                        bits += ((value&((1<<(exp-24))-1))!=0) & !S;
+                    else if(R == std::round_toward_neg_infinity)
+                        bits += ((value&((1<<(exp-24))-1))!=0) & S;
+                }
+            }
+            return bits;
+        }
+
+        /// Convert integer to half-precision floating point.
+        /// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
+        /// \tparam T type to convert (builtin integer type)
+        /// \param value integral value
+        /// \return binary representation of half-precision value
+        template<std::float_round_style R,typename T> uint16 int2half(T value)
+        {
+            return (value<0) ? int2half_impl<R,true>(value) : int2half_impl<R,false>(value);
+        }
+
+        /// Convert half-precision to IEEE single-precision.
+        /// Credit for this goes to [Jeroen van der Zijp](ftp://ftp.fox-toolkit.org/pub/fasthalffloatconversion.pdf).
+        /// \param value binary representation of half-precision value
+        /// \return single-precision value
+        inline float half2float_impl(uint16 value, float, true_type)
+        {
+            typedef bits<float>::type uint32;
 /*			uint32 bits = static_cast<uint32>(value&0x8000) << 16;
-			int abs = value & 0x7FFF;
-			if(abs)
-			{
-				bits |= 0x38000000 << static_cast<unsigned>(abs>=0x7C00);
-				for(; abs<0x400; abs<<=1,bits-=0x800000) ;
-				bits += static_cast<uint32>(abs) << 13;
-			}
+            int abs = value & 0x7FFF;
+            if(abs)
+            {
+                bits |= 0x38000000 << static_cast<unsigned>(abs>=0x7C00);
+                for(; abs<0x400; abs<<=1,bits-=0x800000) ;
+                bits += static_cast<uint32>(abs) << 13;
+            }
 */			static const uint32 mantissa_table[2048] = { 
-				0x00000000, 0x33800000, 0x34000000, 0x34400000, 0x34800000, 0x34A00000, 0x34C00000, 0x34E00000, 0x35000000, 0x35100000, 0x35200000, 0x35300000, 0x35400000, 0x35500000, 0x35600000, 0x35700000, 
-				0x35800000, 0x35880000, 0x35900000, 0x35980000, 0x35A00000, 0x35A80000, 0x35B00000, 0x35B80000, 0x35C00000, 0x35C80000, 0x35D00000, 0x35D80000, 0x35E00000, 0x35E80000, 0x35F00000, 0x35F80000, 
-				0x36000000, 0x36040000, 0x36080000, 0x360C0000, 0x36100000, 0x36140000, 0x36180000, 0x361C0000, 0x36200000, 0x36240000, 0x36280000, 0x362C0000, 0x36300000, 0x36340000, 0x36380000, 0x363C0000, 
-				0x36400000, 0x36440000, 0x36480000, 0x364C0000, 0x36500000, 0x36540000, 0x36580000, 0x365C0000, 0x36600000, 0x36640000, 0x36680000, 0x366C0000, 0x36700000, 0x36740000, 0x36780000, 0x367C0000, 
-				0x36800000, 0x36820000, 0x36840000, 0x36860000, 0x36880000, 0x368A0000, 0x368C0000, 0x368E0000, 0x36900000, 0x36920000, 0x36940000, 0x36960000, 0x36980000, 0x369A0000, 0x369C0000, 0x369E0000, 
-				0x36A00000, 0x36A20000, 0x36A40000, 0x36A60000, 0x36A80000, 0x36AA0000, 0x36AC0000, 0x36AE0000, 0x36B00000, 0x36B20000, 0x36B40000, 0x36B60000, 0x36B80000, 0x36BA0000, 0x36BC0000, 0x36BE0000, 
-				0x36C00000, 0x36C20000, 0x36C40000, 0x36C60000, 0x36C80000, 0x36CA0000, 0x36CC0000, 0x36CE0000, 0x36D00000, 0x36D20000, 0x36D40000, 0x36D60000, 0x36D80000, 0x36DA0000, 0x36DC0000, 0x36DE0000, 
-				0x36E00000, 0x36E20000, 0x36E40000, 0x36E60000, 0x36E80000, 0x36EA0000, 0x36EC0000, 0x36EE0000, 0x36F00000, 0x36F20000, 0x36F40000, 0x36F60000, 0x36F80000, 0x36FA0000, 0x36FC0000, 0x36FE0000, 
-				0x37000000, 0x37010000, 0x37020000, 0x37030000, 0x37040000, 0x37050000, 0x37060000, 0x37070000, 0x37080000, 0x37090000, 0x370A0000, 0x370B0000, 0x370C0000, 0x370D0000, 0x370E0000, 0x370F0000, 
-				0x37100000, 0x37110000, 0x37120000, 0x37130000, 0x37140000, 0x37150000, 0x37160000, 0x37170000, 0x37180000, 0x37190000, 0x371A0000, 0x371B0000, 0x371C0000, 0x371D0000, 0x371E0000, 0x371F0000, 
-				0x37200000, 0x37210000, 0x37220000, 0x37230000, 0x37240000, 0x37250000, 0x37260000, 0x37270000, 0x37280000, 0x37290000, 0x372A0000, 0x372B0000, 0x372C0000, 0x372D0000, 0x372E0000, 0x372F0000, 
-				0x37300000, 0x37310000, 0x37320000, 0x37330000, 0x37340000, 0x37350000, 0x37360000, 0x37370000, 0x37380000, 0x37390000, 0x373A0000, 0x373B0000, 0x373C0000, 0x373D0000, 0x373E0000, 0x373F0000, 
-				0x37400000, 0x37410000, 0x37420000, 0x37430000, 0x37440000, 0x37450000, 0x37460000, 0x37470000, 0x37480000, 0x37490000, 0x374A0000, 0x374B0000, 0x374C0000, 0x374D0000, 0x374E0000, 0x374F0000, 
-				0x37500000, 0x37510000, 0x37520000, 0x37530000, 0x37540000, 0x37550000, 0x37560000, 0x37570000, 0x37580000, 0x37590000, 0x375A0000, 0x375B0000, 0x375C0000, 0x375D0000, 0x375E0000, 0x375F0000, 
-				0x37600000, 0x37610000, 0x37620000, 0x37630000, 0x37640000, 0x37650000, 0x37660000, 0x37670000, 0x37680000, 0x37690000, 0x376A0000, 0x376B0000, 0x376C0000, 0x376D0000, 0x376E0000, 0x376F0000, 
-				0x37700000, 0x37710000, 0x37720000, 0x37730000, 0x37740000, 0x37750000, 0x37760000, 0x37770000, 0x37780000, 0x37790000, 0x377A0000, 0x377B0000, 0x377C0000, 0x377D0000, 0x377E0000, 0x377F0000, 
-				0x37800000, 0x37808000, 0x37810000, 0x37818000, 0x37820000, 0x37828000, 0x37830000, 0x37838000, 0x37840000, 0x37848000, 0x37850000, 0x37858000, 0x37860000, 0x37868000, 0x37870000, 0x37878000, 
-				0x37880000, 0x37888000, 0x37890000, 0x37898000, 0x378A0000, 0x378A8000, 0x378B0000, 0x378B8000, 0x378C0000, 0x378C8000, 0x378D0000, 0x378D8000, 0x378E0000, 0x378E8000, 0x378F0000, 0x378F8000, 
-				0x37900000, 0x37908000, 0x37910000, 0x37918000, 0x37920000, 0x37928000, 0x37930000, 0x37938000, 0x37940000, 0x37948000, 0x37950000, 0x37958000, 0x37960000, 0x37968000, 0x37970000, 0x37978000, 
-				0x37980000, 0x37988000, 0x37990000, 0x37998000, 0x379A0000, 0x379A8000, 0x379B0000, 0x379B8000, 0x379C0000, 0x379C8000, 0x379D0000, 0x379D8000, 0x379E0000, 0x379E8000, 0x379F0000, 0x379F8000, 
-				0x37A00000, 0x37A08000, 0x37A10000, 0x37A18000, 0x37A20000, 0x37A28000, 0x37A30000, 0x37A38000, 0x37A40000, 0x37A48000, 0x37A50000, 0x37A58000, 0x37A60000, 0x37A68000, 0x37A70000, 0x37A78000, 
-				0x37A80000, 0x37A88000, 0x37A90000, 0x37A98000, 0x37AA0000, 0x37AA8000, 0x37AB0000, 0x37AB8000, 0x37AC0000, 0x37AC8000, 0x37AD0000, 0x37AD8000, 0x37AE0000, 0x37AE8000, 0x37AF0000, 0x37AF8000, 
-				0x37B00000, 0x37B08000, 0x37B10000, 0x37B18000, 0x37B20000, 0x37B28000, 0x37B30000, 0x37B38000, 0x37B40000, 0x37B48000, 0x37B50000, 0x37B58000, 0x37B60000, 0x37B68000, 0x37B70000, 0x37B78000, 
-				0x37B80000, 0x37B88000, 0x37B90000, 0x37B98000, 0x37BA0000, 0x37BA8000, 0x37BB0000, 0x37BB8000, 0x37BC0000, 0x37BC8000, 0x37BD0000, 0x37BD8000, 0x37BE0000, 0x37BE8000, 0x37BF0000, 0x37BF8000, 
-				0x37C00000, 0x37C08000, 0x37C10000, 0x37C18000, 0x37C20000, 0x37C28000, 0x37C30000, 0x37C38000, 0x37C40000, 0x37C48000, 0x37C50000, 0x37C58000, 0x37C60000, 0x37C68000, 0x37C70000, 0x37C78000, 
-				0x37C80000, 0x37C88000, 0x37C90000, 0x37C98000, 0x37CA0000, 0x37CA8000, 0x37CB0000, 0x37CB8000, 0x37CC0000, 0x37CC8000, 0x37CD0000, 0x37CD8000, 0x37CE0000, 0x37CE8000, 0x37CF0000, 0x37CF8000, 
-				0x37D00000, 0x37D08000, 0x37D10000, 0x37D18000, 0x37D20000, 0x37D28000, 0x37D30000, 0x37D38000, 0x37D40000, 0x37D48000, 0x37D50000, 0x37D58000, 0x37D60000, 0x37D68000, 0x37D70000, 0x37D78000, 
-				0x37D80000, 0x37D88000, 0x37D90000, 0x37D98000, 0x37DA0000, 0x37DA8000, 0x37DB0000, 0x37DB8000, 0x37DC0000, 0x37DC8000, 0x37DD0000, 0x37DD8000, 0x37DE0000, 0x37DE8000, 0x37DF0000, 0x37DF8000, 
-				0x37E00000, 0x37E08000, 0x37E10000, 0x37E18000, 0x37E20000, 0x37E28000, 0x37E30000, 0x37E38000, 0x37E40000, 0x37E48000, 0x37E50000, 0x37E58000, 0x37E60000, 0x37E68000, 0x37E70000, 0x37E78000, 
-				0x37E80000, 0x37E88000, 0x37E90000, 0x37E98000, 0x37EA0000, 0x37EA8000, 0x37EB0000, 0x37EB8000, 0x37EC0000, 0x37EC8000, 0x37ED0000, 0x37ED8000, 0x37EE0000, 0x37EE8000, 0x37EF0000, 0x37EF8000, 
-				0x37F00000, 0x37F08000, 0x37F10000, 0x37F18000, 0x37F20000, 0x37F28000, 0x37F30000, 0x37F38000, 0x37F40000, 0x37F48000, 0x37F50000, 0x37F58000, 0x37F60000, 0x37F68000, 0x37F70000, 0x37F78000, 
-				0x37F80000, 0x37F88000, 0x37F90000, 0x37F98000, 0x37FA0000, 0x37FA8000, 0x37FB0000, 0x37FB8000, 0x37FC0000, 0x37FC8000, 0x37FD0000, 0x37FD8000, 0x37FE0000, 0x37FE8000, 0x37FF0000, 0x37FF8000, 
-				0x38000000, 0x38004000, 0x38008000, 0x3800C000, 0x38010000, 0x38014000, 0x38018000, 0x3801C000, 0x38020000, 0x38024000, 0x38028000, 0x3802C000, 0x38030000, 0x38034000, 0x38038000, 0x3803C000, 
-				0x38040000, 0x38044000, 0x38048000, 0x3804C000, 0x38050000, 0x38054000, 0x38058000, 0x3805C000, 0x38060000, 0x38064000, 0x38068000, 0x3806C000, 0x38070000, 0x38074000, 0x38078000, 0x3807C000, 
-				0x38080000, 0x38084000, 0x38088000, 0x3808C000, 0x38090000, 0x38094000, 0x38098000, 0x3809C000, 0x380A0000, 0x380A4000, 0x380A8000, 0x380AC000, 0x380B0000, 0x380B4000, 0x380B8000, 0x380BC000, 
-				0x380C0000, 0x380C4000, 0x380C8000, 0x380CC000, 0x380D0000, 0x380D4000, 0x380D8000, 0x380DC000, 0x380E0000, 0x380E4000, 0x380E8000, 0x380EC000, 0x380F0000, 0x380F4000, 0x380F8000, 0x380FC000, 
-				0x38100000, 0x38104000, 0x38108000, 0x3810C000, 0x38110000, 0x38114000, 0x38118000, 0x3811C000, 0x38120000, 0x38124000, 0x38128000, 0x3812C000, 0x38130000, 0x38134000, 0x38138000, 0x3813C000, 
-				0x38140000, 0x38144000, 0x38148000, 0x3814C000, 0x38150000, 0x38154000, 0x38158000, 0x3815C000, 0x38160000, 0x38164000, 0x38168000, 0x3816C000, 0x38170000, 0x38174000, 0x38178000, 0x3817C000, 
-				0x38180000, 0x38184000, 0x38188000, 0x3818C000, 0x38190000, 0x38194000, 0x38198000, 0x3819C000, 0x381A0000, 0x381A4000, 0x381A8000, 0x381AC000, 0x381B0000, 0x381B4000, 0x381B8000, 0x381BC000, 
-				0x381C0000, 0x381C4000, 0x381C8000, 0x381CC000, 0x381D0000, 0x381D4000, 0x381D8000, 0x381DC000, 0x381E0000, 0x381E4000, 0x381E8000, 0x381EC000, 0x381F0000, 0x381F4000, 0x381F8000, 0x381FC000, 
-				0x38200000, 0x38204000, 0x38208000, 0x3820C000, 0x38210000, 0x38214000, 0x38218000, 0x3821C000, 0x38220000, 0x38224000, 0x38228000, 0x3822C000, 0x38230000, 0x38234000, 0x38238000, 0x3823C000, 
-				0x38240000, 0x38244000, 0x38248000, 0x3824C000, 0x38250000, 0x38254000, 0x38258000, 0x3825C000, 0x38260000, 0x38264000, 0x38268000, 0x3826C000, 0x38270000, 0x38274000, 0x38278000, 0x3827C000, 
-				0x38280000, 0x38284000, 0x38288000, 0x3828C000, 0x38290000, 0x38294000, 0x38298000, 0x3829C000, 0x382A0000, 0x382A4000, 0x382A8000, 0x382AC000, 0x382B0000, 0x382B4000, 0x382B8000, 0x382BC000, 
-				0x382C0000, 0x382C4000, 0x382C8000, 0x382CC000, 0x382D0000, 0x382D4000, 0x382D8000, 0x382DC000, 0x382E0000, 0x382E4000, 0x382E8000, 0x382EC000, 0x382F0000, 0x382F4000, 0x382F8000, 0x382FC000, 
-				0x38300000, 0x38304000, 0x38308000, 0x3830C000, 0x38310000, 0x38314000, 0x38318000, 0x3831C000, 0x38320000, 0x38324000, 0x38328000, 0x3832C000, 0x38330000, 0x38334000, 0x38338000, 0x3833C000, 
-				0x38340000, 0x38344000, 0x38348000, 0x3834C000, 0x38350000, 0x38354000, 0x38358000, 0x3835C000, 0x38360000, 0x38364000, 0x38368000, 0x3836C000, 0x38370000, 0x38374000, 0x38378000, 0x3837C000, 
-				0x38380000, 0x38384000, 0x38388000, 0x3838C000, 0x38390000, 0x38394000, 0x38398000, 0x3839C000, 0x383A0000, 0x383A4000, 0x383A8000, 0x383AC000, 0x383B0000, 0x383B4000, 0x383B8000, 0x383BC000, 
-				0x383C0000, 0x383C4000, 0x383C8000, 0x383CC000, 0x383D0000, 0x383D4000, 0x383D8000, 0x383DC000, 0x383E0000, 0x383E4000, 0x383E8000, 0x383EC000, 0x383F0000, 0x383F4000, 0x383F8000, 0x383FC000, 
-				0x38400000, 0x38404000, 0x38408000, 0x3840C000, 0x38410000, 0x38414000, 0x38418000, 0x3841C000, 0x38420000, 0x38424000, 0x38428000, 0x3842C000, 0x38430000, 0x38434000, 0x38438000, 0x3843C000, 
-				0x38440000, 0x38444000, 0x38448000, 0x3844C000, 0x38450000, 0x38454000, 0x38458000, 0x3845C000, 0x38460000, 0x38464000, 0x38468000, 0x3846C000, 0x38470000, 0x38474000, 0x38478000, 0x3847C000, 
-				0x38480000, 0x38484000, 0x38488000, 0x3848C000, 0x38490000, 0x38494000, 0x38498000, 0x3849C000, 0x384A0000, 0x384A4000, 0x384A8000, 0x384AC000, 0x384B0000, 0x384B4000, 0x384B8000, 0x384BC000, 
-				0x384C0000, 0x384C4000, 0x384C8000, 0x384CC000, 0x384D0000, 0x384D4000, 0x384D8000, 0x384DC000, 0x384E0000, 0x384E4000, 0x384E8000, 0x384EC000, 0x384F0000, 0x384F4000, 0x384F8000, 0x384FC000, 
-				0x38500000, 0x38504000, 0x38508000, 0x3850C000, 0x38510000, 0x38514000, 0x38518000, 0x3851C000, 0x38520000, 0x38524000, 0x38528000, 0x3852C000, 0x38530000, 0x38534000, 0x38538000, 0x3853C000, 
-				0x38540000, 0x38544000, 0x38548000, 0x3854C000, 0x38550000, 0x38554000, 0x38558000, 0x3855C000, 0x38560000, 0x38564000, 0x38568000, 0x3856C000, 0x38570000, 0x38574000, 0x38578000, 0x3857C000, 
-				0x38580000, 0x38584000, 0x38588000, 0x3858C000, 0x38590000, 0x38594000, 0x38598000, 0x3859C000, 0x385A0000, 0x385A4000, 0x385A8000, 0x385AC000, 0x385B0000, 0x385B4000, 0x385B8000, 0x385BC000, 
-				0x385C0000, 0x385C4000, 0x385C8000, 0x385CC000, 0x385D0000, 0x385D4000, 0x385D8000, 0x385DC000, 0x385E0000, 0x385E4000, 0x385E8000, 0x385EC000, 0x385F0000, 0x385F4000, 0x385F8000, 0x385FC000, 
-				0x38600000, 0x38604000, 0x38608000, 0x3860C000, 0x38610000, 0x38614000, 0x38618000, 0x3861C000, 0x38620000, 0x38624000, 0x38628000, 0x3862C000, 0x38630000, 0x38634000, 0x38638000, 0x3863C000, 
-				0x38640000, 0x38644000, 0x38648000, 0x3864C000, 0x38650000, 0x38654000, 0x38658000, 0x3865C000, 0x38660000, 0x38664000, 0x38668000, 0x3866C000, 0x38670000, 0x38674000, 0x38678000, 0x3867C000, 
-				0x38680000, 0x38684000, 0x38688000, 0x3868C000, 0x38690000, 0x38694000, 0x38698000, 0x3869C000, 0x386A0000, 0x386A4000, 0x386A8000, 0x386AC000, 0x386B0000, 0x386B4000, 0x386B8000, 0x386BC000, 
-				0x386C0000, 0x386C4000, 0x386C8000, 0x386CC000, 0x386D0000, 0x386D4000, 0x386D8000, 0x386DC000, 0x386E0000, 0x386E4000, 0x386E8000, 0x386EC000, 0x386F0000, 0x386F4000, 0x386F8000, 0x386FC000, 
-				0x38700000, 0x38704000, 0x38708000, 0x3870C000, 0x38710000, 0x38714000, 0x38718000, 0x3871C000, 0x38720000, 0x38724000, 0x38728000, 0x3872C000, 0x38730000, 0x38734000, 0x38738000, 0x3873C000, 
-				0x38740000, 0x38744000, 0x38748000, 0x3874C000, 0x38750000, 0x38754000, 0x38758000, 0x3875C000, 0x38760000, 0x38764000, 0x38768000, 0x3876C000, 0x38770000, 0x38774000, 0x38778000, 0x3877C000, 
-				0x38780000, 0x38784000, 0x38788000, 0x3878C000, 0x38790000, 0x38794000, 0x38798000, 0x3879C000, 0x387A0000, 0x387A4000, 0x387A8000, 0x387AC000, 0x387B0000, 0x387B4000, 0x387B8000, 0x387BC000, 
-				0x387C0000, 0x387C4000, 0x387C8000, 0x387CC000, 0x387D0000, 0x387D4000, 0x387D8000, 0x387DC000, 0x387E0000, 0x387E4000, 0x387E8000, 0x387EC000, 0x387F0000, 0x387F4000, 0x387F8000, 0x387FC000, 
-				0x38000000, 0x38002000, 0x38004000, 0x38006000, 0x38008000, 0x3800A000, 0x3800C000, 0x3800E000, 0x38010000, 0x38012000, 0x38014000, 0x38016000, 0x38018000, 0x3801A000, 0x3801C000, 0x3801E000, 
-				0x38020000, 0x38022000, 0x38024000, 0x38026000, 0x38028000, 0x3802A000, 0x3802C000, 0x3802E000, 0x38030000, 0x38032000, 0x38034000, 0x38036000, 0x38038000, 0x3803A000, 0x3803C000, 0x3803E000, 
-				0x38040000, 0x38042000, 0x38044000, 0x38046000, 0x38048000, 0x3804A000, 0x3804C000, 0x3804E000, 0x38050000, 0x38052000, 0x38054000, 0x38056000, 0x38058000, 0x3805A000, 0x3805C000, 0x3805E000, 
-				0x38060000, 0x38062000, 0x38064000, 0x38066000, 0x38068000, 0x3806A000, 0x3806C000, 0x3806E000, 0x38070000, 0x38072000, 0x38074000, 0x38076000, 0x38078000, 0x3807A000, 0x3807C000, 0x3807E000, 
-				0x38080000, 0x38082000, 0x38084000, 0x38086000, 0x38088000, 0x3808A000, 0x3808C000, 0x3808E000, 0x38090000, 0x38092000, 0x38094000, 0x38096000, 0x38098000, 0x3809A000, 0x3809C000, 0x3809E000, 
-				0x380A0000, 0x380A2000, 0x380A4000, 0x380A6000, 0x380A8000, 0x380AA000, 0x380AC000, 0x380AE000, 0x380B0000, 0x380B2000, 0x380B4000, 0x380B6000, 0x380B8000, 0x380BA000, 0x380BC000, 0x380BE000, 
-				0x380C0000, 0x380C2000, 0x380C4000, 0x380C6000, 0x380C8000, 0x380CA000, 0x380CC000, 0x380CE000, 0x380D0000, 0x380D2000, 0x380D4000, 0x380D6000, 0x380D8000, 0x380DA000, 0x380DC000, 0x380DE000, 
-				0x380E0000, 0x380E2000, 0x380E4000, 0x380E6000, 0x380E8000, 0x380EA000, 0x380EC000, 0x380EE000, 0x380F0000, 0x380F2000, 0x380F4000, 0x380F6000, 0x380F8000, 0x380FA000, 0x380FC000, 0x380FE000, 
-				0x38100000, 0x38102000, 0x38104000, 0x38106000, 0x38108000, 0x3810A000, 0x3810C000, 0x3810E000, 0x38110000, 0x38112000, 0x38114000, 0x38116000, 0x38118000, 0x3811A000, 0x3811C000, 0x3811E000, 
-				0x38120000, 0x38122000, 0x38124000, 0x38126000, 0x38128000, 0x3812A000, 0x3812C000, 0x3812E000, 0x38130000, 0x38132000, 0x38134000, 0x38136000, 0x38138000, 0x3813A000, 0x3813C000, 0x3813E000, 
-				0x38140000, 0x38142000, 0x38144000, 0x38146000, 0x38148000, 0x3814A000, 0x3814C000, 0x3814E000, 0x38150000, 0x38152000, 0x38154000, 0x38156000, 0x38158000, 0x3815A000, 0x3815C000, 0x3815E000, 
-				0x38160000, 0x38162000, 0x38164000, 0x38166000, 0x38168000, 0x3816A000, 0x3816C000, 0x3816E000, 0x38170000, 0x38172000, 0x38174000, 0x38176000, 0x38178000, 0x3817A000, 0x3817C000, 0x3817E000, 
-				0x38180000, 0x38182000, 0x38184000, 0x38186000, 0x38188000, 0x3818A000, 0x3818C000, 0x3818E000, 0x38190000, 0x38192000, 0x38194000, 0x38196000, 0x38198000, 0x3819A000, 0x3819C000, 0x3819E000, 
-				0x381A0000, 0x381A2000, 0x381A4000, 0x381A6000, 0x381A8000, 0x381AA000, 0x381AC000, 0x381AE000, 0x381B0000, 0x381B2000, 0x381B4000, 0x381B6000, 0x381B8000, 0x381BA000, 0x381BC000, 0x381BE000, 
-				0x381C0000, 0x381C2000, 0x381C4000, 0x381C6000, 0x381C8000, 0x381CA000, 0x381CC000, 0x381CE000, 0x381D0000, 0x381D2000, 0x381D4000, 0x381D6000, 0x381D8000, 0x381DA000, 0x381DC000, 0x381DE000, 
-				0x381E0000, 0x381E2000, 0x381E4000, 0x381E6000, 0x381E8000, 0x381EA000, 0x381EC000, 0x381EE000, 0x381F0000, 0x381F2000, 0x381F4000, 0x381F6000, 0x381F8000, 0x381FA000, 0x381FC000, 0x381FE000, 
-				0x38200000, 0x38202000, 0x38204000, 0x38206000, 0x38208000, 0x3820A000, 0x3820C000, 0x3820E000, 0x38210000, 0x38212000, 0x38214000, 0x38216000, 0x38218000, 0x3821A000, 0x3821C000, 0x3821E000, 
-				0x38220000, 0x38222000, 0x38224000, 0x38226000, 0x38228000, 0x3822A000, 0x3822C000, 0x3822E000, 0x38230000, 0x38232000, 0x38234000, 0x38236000, 0x38238000, 0x3823A000, 0x3823C000, 0x3823E000, 
-				0x38240000, 0x38242000, 0x38244000, 0x38246000, 0x38248000, 0x3824A000, 0x3824C000, 0x3824E000, 0x38250000, 0x38252000, 0x38254000, 0x38256000, 0x38258000, 0x3825A000, 0x3825C000, 0x3825E000, 
-				0x38260000, 0x38262000, 0x38264000, 0x38266000, 0x38268000, 0x3826A000, 0x3826C000, 0x3826E000, 0x38270000, 0x38272000, 0x38274000, 0x38276000, 0x38278000, 0x3827A000, 0x3827C000, 0x3827E000, 
-				0x38280000, 0x38282000, 0x38284000, 0x38286000, 0x38288000, 0x3828A000, 0x3828C000, 0x3828E000, 0x38290000, 0x38292000, 0x38294000, 0x38296000, 0x38298000, 0x3829A000, 0x3829C000, 0x3829E000, 
-				0x382A0000, 0x382A2000, 0x382A4000, 0x382A6000, 0x382A8000, 0x382AA000, 0x382AC000, 0x382AE000, 0x382B0000, 0x382B2000, 0x382B4000, 0x382B6000, 0x382B8000, 0x382BA000, 0x382BC000, 0x382BE000, 
-				0x382C0000, 0x382C2000, 0x382C4000, 0x382C6000, 0x382C8000, 0x382CA000, 0x382CC000, 0x382CE000, 0x382D0000, 0x382D2000, 0x382D4000, 0x382D6000, 0x382D8000, 0x382DA000, 0x382DC000, 0x382DE000, 
-				0x382E0000, 0x382E2000, 0x382E4000, 0x382E6000, 0x382E8000, 0x382EA000, 0x382EC000, 0x382EE000, 0x382F0000, 0x382F2000, 0x382F4000, 0x382F6000, 0x382F8000, 0x382FA000, 0x382FC000, 0x382FE000, 
-				0x38300000, 0x38302000, 0x38304000, 0x38306000, 0x38308000, 0x3830A000, 0x3830C000, 0x3830E000, 0x38310000, 0x38312000, 0x38314000, 0x38316000, 0x38318000, 0x3831A000, 0x3831C000, 0x3831E000, 
-				0x38320000, 0x38322000, 0x38324000, 0x38326000, 0x38328000, 0x3832A000, 0x3832C000, 0x3832E000, 0x38330000, 0x38332000, 0x38334000, 0x38336000, 0x38338000, 0x3833A000, 0x3833C000, 0x3833E000, 
-				0x38340000, 0x38342000, 0x38344000, 0x38346000, 0x38348000, 0x3834A000, 0x3834C000, 0x3834E000, 0x38350000, 0x38352000, 0x38354000, 0x38356000, 0x38358000, 0x3835A000, 0x3835C000, 0x3835E000, 
-				0x38360000, 0x38362000, 0x38364000, 0x38366000, 0x38368000, 0x3836A000, 0x3836C000, 0x3836E000, 0x38370000, 0x38372000, 0x38374000, 0x38376000, 0x38378000, 0x3837A000, 0x3837C000, 0x3837E000, 
-				0x38380000, 0x38382000, 0x38384000, 0x38386000, 0x38388000, 0x3838A000, 0x3838C000, 0x3838E000, 0x38390000, 0x38392000, 0x38394000, 0x38396000, 0x38398000, 0x3839A000, 0x3839C000, 0x3839E000, 
-				0x383A0000, 0x383A2000, 0x383A4000, 0x383A6000, 0x383A8000, 0x383AA000, 0x383AC000, 0x383AE000, 0x383B0000, 0x383B2000, 0x383B4000, 0x383B6000, 0x383B8000, 0x383BA000, 0x383BC000, 0x383BE000, 
-				0x383C0000, 0x383C2000, 0x383C4000, 0x383C6000, 0x383C8000, 0x383CA000, 0x383CC000, 0x383CE000, 0x383D0000, 0x383D2000, 0x383D4000, 0x383D6000, 0x383D8000, 0x383DA000, 0x383DC000, 0x383DE000, 
-				0x383E0000, 0x383E2000, 0x383E4000, 0x383E6000, 0x383E8000, 0x383EA000, 0x383EC000, 0x383EE000, 0x383F0000, 0x383F2000, 0x383F4000, 0x383F6000, 0x383F8000, 0x383FA000, 0x383FC000, 0x383FE000, 
-				0x38400000, 0x38402000, 0x38404000, 0x38406000, 0x38408000, 0x3840A000, 0x3840C000, 0x3840E000, 0x38410000, 0x38412000, 0x38414000, 0x38416000, 0x38418000, 0x3841A000, 0x3841C000, 0x3841E000, 
-				0x38420000, 0x38422000, 0x38424000, 0x38426000, 0x38428000, 0x3842A000, 0x3842C000, 0x3842E000, 0x38430000, 0x38432000, 0x38434000, 0x38436000, 0x38438000, 0x3843A000, 0x3843C000, 0x3843E000, 
-				0x38440000, 0x38442000, 0x38444000, 0x38446000, 0x38448000, 0x3844A000, 0x3844C000, 0x3844E000, 0x38450000, 0x38452000, 0x38454000, 0x38456000, 0x38458000, 0x3845A000, 0x3845C000, 0x3845E000, 
-				0x38460000, 0x38462000, 0x38464000, 0x38466000, 0x38468000, 0x3846A000, 0x3846C000, 0x3846E000, 0x38470000, 0x38472000, 0x38474000, 0x38476000, 0x38478000, 0x3847A000, 0x3847C000, 0x3847E000, 
-				0x38480000, 0x38482000, 0x38484000, 0x38486000, 0x38488000, 0x3848A000, 0x3848C000, 0x3848E000, 0x38490000, 0x38492000, 0x38494000, 0x38496000, 0x38498000, 0x3849A000, 0x3849C000, 0x3849E000, 
-				0x384A0000, 0x384A2000, 0x384A4000, 0x384A6000, 0x384A8000, 0x384AA000, 0x384AC000, 0x384AE000, 0x384B0000, 0x384B2000, 0x384B4000, 0x384B6000, 0x384B8000, 0x384BA000, 0x384BC000, 0x384BE000, 
-				0x384C0000, 0x384C2000, 0x384C4000, 0x384C6000, 0x384C8000, 0x384CA000, 0x384CC000, 0x384CE000, 0x384D0000, 0x384D2000, 0x384D4000, 0x384D6000, 0x384D8000, 0x384DA000, 0x384DC000, 0x384DE000, 
-				0x384E0000, 0x384E2000, 0x384E4000, 0x384E6000, 0x384E8000, 0x384EA000, 0x384EC000, 0x384EE000, 0x384F0000, 0x384F2000, 0x384F4000, 0x384F6000, 0x384F8000, 0x384FA000, 0x384FC000, 0x384FE000, 
-				0x38500000, 0x38502000, 0x38504000, 0x38506000, 0x38508000, 0x3850A000, 0x3850C000, 0x3850E000, 0x38510000, 0x38512000, 0x38514000, 0x38516000, 0x38518000, 0x3851A000, 0x3851C000, 0x3851E000, 
-				0x38520000, 0x38522000, 0x38524000, 0x38526000, 0x38528000, 0x3852A000, 0x3852C000, 0x3852E000, 0x38530000, 0x38532000, 0x38534000, 0x38536000, 0x38538000, 0x3853A000, 0x3853C000, 0x3853E000, 
-				0x38540000, 0x38542000, 0x38544000, 0x38546000, 0x38548000, 0x3854A000, 0x3854C000, 0x3854E000, 0x38550000, 0x38552000, 0x38554000, 0x38556000, 0x38558000, 0x3855A000, 0x3855C000, 0x3855E000, 
-				0x38560000, 0x38562000, 0x38564000, 0x38566000, 0x38568000, 0x3856A000, 0x3856C000, 0x3856E000, 0x38570000, 0x38572000, 0x38574000, 0x38576000, 0x38578000, 0x3857A000, 0x3857C000, 0x3857E000, 
-				0x38580000, 0x38582000, 0x38584000, 0x38586000, 0x38588000, 0x3858A000, 0x3858C000, 0x3858E000, 0x38590000, 0x38592000, 0x38594000, 0x38596000, 0x38598000, 0x3859A000, 0x3859C000, 0x3859E000, 
-				0x385A0000, 0x385A2000, 0x385A4000, 0x385A6000, 0x385A8000, 0x385AA000, 0x385AC000, 0x385AE000, 0x385B0000, 0x385B2000, 0x385B4000, 0x385B6000, 0x385B8000, 0x385BA000, 0x385BC000, 0x385BE000, 
-				0x385C0000, 0x385C2000, 0x385C4000, 0x385C6000, 0x385C8000, 0x385CA000, 0x385CC000, 0x385CE000, 0x385D0000, 0x385D2000, 0x385D4000, 0x385D6000, 0x385D8000, 0x385DA000, 0x385DC000, 0x385DE000, 
-				0x385E0000, 0x385E2000, 0x385E4000, 0x385E6000, 0x385E8000, 0x385EA000, 0x385EC000, 0x385EE000, 0x385F0000, 0x385F2000, 0x385F4000, 0x385F6000, 0x385F8000, 0x385FA000, 0x385FC000, 0x385FE000, 
-				0x38600000, 0x38602000, 0x38604000, 0x38606000, 0x38608000, 0x3860A000, 0x3860C000, 0x3860E000, 0x38610000, 0x38612000, 0x38614000, 0x38616000, 0x38618000, 0x3861A000, 0x3861C000, 0x3861E000, 
-				0x38620000, 0x38622000, 0x38624000, 0x38626000, 0x38628000, 0x3862A000, 0x3862C000, 0x3862E000, 0x38630000, 0x38632000, 0x38634000, 0x38636000, 0x38638000, 0x3863A000, 0x3863C000, 0x3863E000, 
-				0x38640000, 0x38642000, 0x38644000, 0x38646000, 0x38648000, 0x3864A000, 0x3864C000, 0x3864E000, 0x38650000, 0x38652000, 0x38654000, 0x38656000, 0x38658000, 0x3865A000, 0x3865C000, 0x3865E000, 
-				0x38660000, 0x38662000, 0x38664000, 0x38666000, 0x38668000, 0x3866A000, 0x3866C000, 0x3866E000, 0x38670000, 0x38672000, 0x38674000, 0x38676000, 0x38678000, 0x3867A000, 0x3867C000, 0x3867E000, 
-				0x38680000, 0x38682000, 0x38684000, 0x38686000, 0x38688000, 0x3868A000, 0x3868C000, 0x3868E000, 0x38690000, 0x38692000, 0x38694000, 0x38696000, 0x38698000, 0x3869A000, 0x3869C000, 0x3869E000, 
-				0x386A0000, 0x386A2000, 0x386A4000, 0x386A6000, 0x386A8000, 0x386AA000, 0x386AC000, 0x386AE000, 0x386B0000, 0x386B2000, 0x386B4000, 0x386B6000, 0x386B8000, 0x386BA000, 0x386BC000, 0x386BE000, 
-				0x386C0000, 0x386C2000, 0x386C4000, 0x386C6000, 0x386C8000, 0x386CA000, 0x386CC000, 0x386CE000, 0x386D0000, 0x386D2000, 0x386D4000, 0x386D6000, 0x386D8000, 0x386DA000, 0x386DC000, 0x386DE000, 
-				0x386E0000, 0x386E2000, 0x386E4000, 0x386E6000, 0x386E8000, 0x386EA000, 0x386EC000, 0x386EE000, 0x386F0000, 0x386F2000, 0x386F4000, 0x386F6000, 0x386F8000, 0x386FA000, 0x386FC000, 0x386FE000, 
-				0x38700000, 0x38702000, 0x38704000, 0x38706000, 0x38708000, 0x3870A000, 0x3870C000, 0x3870E000, 0x38710000, 0x38712000, 0x38714000, 0x38716000, 0x38718000, 0x3871A000, 0x3871C000, 0x3871E000, 
-				0x38720000, 0x38722000, 0x38724000, 0x38726000, 0x38728000, 0x3872A000, 0x3872C000, 0x3872E000, 0x38730000, 0x38732000, 0x38734000, 0x38736000, 0x38738000, 0x3873A000, 0x3873C000, 0x3873E000, 
-				0x38740000, 0x38742000, 0x38744000, 0x38746000, 0x38748000, 0x3874A000, 0x3874C000, 0x3874E000, 0x38750000, 0x38752000, 0x38754000, 0x38756000, 0x38758000, 0x3875A000, 0x3875C000, 0x3875E000, 
-				0x38760000, 0x38762000, 0x38764000, 0x38766000, 0x38768000, 0x3876A000, 0x3876C000, 0x3876E000, 0x38770000, 0x38772000, 0x38774000, 0x38776000, 0x38778000, 0x3877A000, 0x3877C000, 0x3877E000, 
-				0x38780000, 0x38782000, 0x38784000, 0x38786000, 0x38788000, 0x3878A000, 0x3878C000, 0x3878E000, 0x38790000, 0x38792000, 0x38794000, 0x38796000, 0x38798000, 0x3879A000, 0x3879C000, 0x3879E000, 
-				0x387A0000, 0x387A2000, 0x387A4000, 0x387A6000, 0x387A8000, 0x387AA000, 0x387AC000, 0x387AE000, 0x387B0000, 0x387B2000, 0x387B4000, 0x387B6000, 0x387B8000, 0x387BA000, 0x387BC000, 0x387BE000, 
-				0x387C0000, 0x387C2000, 0x387C4000, 0x387C6000, 0x387C8000, 0x387CA000, 0x387CC000, 0x387CE000, 0x387D0000, 0x387D2000, 0x387D4000, 0x387D6000, 0x387D8000, 0x387DA000, 0x387DC000, 0x387DE000, 
-				0x387E0000, 0x387E2000, 0x387E4000, 0x387E6000, 0x387E8000, 0x387EA000, 0x387EC000, 0x387EE000, 0x387F0000, 0x387F2000, 0x387F4000, 0x387F6000, 0x387F8000, 0x387FA000, 0x387FC000, 0x387FE000 };
-			static const uint32 exponent_table[64] = { 
-				0x00000000, 0x00800000, 0x01000000, 0x01800000, 0x02000000, 0x02800000, 0x03000000, 0x03800000, 0x04000000, 0x04800000, 0x05000000, 0x05800000, 0x06000000, 0x06800000, 0x07000000, 0x07800000, 
-				0x08000000, 0x08800000, 0x09000000, 0x09800000, 0x0A000000, 0x0A800000, 0x0B000000, 0x0B800000, 0x0C000000, 0x0C800000, 0x0D000000, 0x0D800000, 0x0E000000, 0x0E800000, 0x0F000000, 0x47800000, 
-				0x80000000, 0x80800000, 0x81000000, 0x81800000, 0x82000000, 0x82800000, 0x83000000, 0x83800000, 0x84000000, 0x84800000, 0x85000000, 0x85800000, 0x86000000, 0x86800000, 0x87000000, 0x87800000, 
-				0x88000000, 0x88800000, 0x89000000, 0x89800000, 0x8A000000, 0x8A800000, 0x8B000000, 0x8B800000, 0x8C000000, 0x8C800000, 0x8D000000, 0x8D800000, 0x8E000000, 0x8E800000, 0x8F000000, 0xC7800000 };
-			static const unsigned short offset_table[64] = { 
-				   0, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 
-				   0, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024 };
-			uint32 bits = mantissa_table[offset_table[value>>10]+(value&0x3FF)] + exponent_table[value>>10];
+                0x00000000, 0x33800000, 0x34000000, 0x34400000, 0x34800000, 0x34A00000, 0x34C00000, 0x34E00000, 0x35000000, 0x35100000, 0x35200000, 0x35300000, 0x35400000, 0x35500000, 0x35600000, 0x35700000, 
+                0x35800000, 0x35880000, 0x35900000, 0x35980000, 0x35A00000, 0x35A80000, 0x35B00000, 0x35B80000, 0x35C00000, 0x35C80000, 0x35D00000, 0x35D80000, 0x35E00000, 0x35E80000, 0x35F00000, 0x35F80000, 
+                0x36000000, 0x36040000, 0x36080000, 0x360C0000, 0x36100000, 0x36140000, 0x36180000, 0x361C0000, 0x36200000, 0x36240000, 0x36280000, 0x362C0000, 0x36300000, 0x36340000, 0x36380000, 0x363C0000, 
+                0x36400000, 0x36440000, 0x36480000, 0x364C0000, 0x36500000, 0x36540000, 0x36580000, 0x365C0000, 0x36600000, 0x36640000, 0x36680000, 0x366C0000, 0x36700000, 0x36740000, 0x36780000, 0x367C0000, 
+                0x36800000, 0x36820000, 0x36840000, 0x36860000, 0x36880000, 0x368A0000, 0x368C0000, 0x368E0000, 0x36900000, 0x36920000, 0x36940000, 0x36960000, 0x36980000, 0x369A0000, 0x369C0000, 0x369E0000, 
+                0x36A00000, 0x36A20000, 0x36A40000, 0x36A60000, 0x36A80000, 0x36AA0000, 0x36AC0000, 0x36AE0000, 0x36B00000, 0x36B20000, 0x36B40000, 0x36B60000, 0x36B80000, 0x36BA0000, 0x36BC0000, 0x36BE0000, 
+                0x36C00000, 0x36C20000, 0x36C40000, 0x36C60000, 0x36C80000, 0x36CA0000, 0x36CC0000, 0x36CE0000, 0x36D00000, 0x36D20000, 0x36D40000, 0x36D60000, 0x36D80000, 0x36DA0000, 0x36DC0000, 0x36DE0000, 
+                0x36E00000, 0x36E20000, 0x36E40000, 0x36E60000, 0x36E80000, 0x36EA0000, 0x36EC0000, 0x36EE0000, 0x36F00000, 0x36F20000, 0x36F40000, 0x36F60000, 0x36F80000, 0x36FA0000, 0x36FC0000, 0x36FE0000, 
+                0x37000000, 0x37010000, 0x37020000, 0x37030000, 0x37040000, 0x37050000, 0x37060000, 0x37070000, 0x37080000, 0x37090000, 0x370A0000, 0x370B0000, 0x370C0000, 0x370D0000, 0x370E0000, 0x370F0000, 
+                0x37100000, 0x37110000, 0x37120000, 0x37130000, 0x37140000, 0x37150000, 0x37160000, 0x37170000, 0x37180000, 0x37190000, 0x371A0000, 0x371B0000, 0x371C0000, 0x371D0000, 0x371E0000, 0x371F0000, 
+                0x37200000, 0x37210000, 0x37220000, 0x37230000, 0x37240000, 0x37250000, 0x37260000, 0x37270000, 0x37280000, 0x37290000, 0x372A0000, 0x372B0000, 0x372C0000, 0x372D0000, 0x372E0000, 0x372F0000, 
+                0x37300000, 0x37310000, 0x37320000, 0x37330000, 0x37340000, 0x37350000, 0x37360000, 0x37370000, 0x37380000, 0x37390000, 0x373A0000, 0x373B0000, 0x373C0000, 0x373D0000, 0x373E0000, 0x373F0000, 
+                0x37400000, 0x37410000, 0x37420000, 0x37430000, 0x37440000, 0x37450000, 0x37460000, 0x37470000, 0x37480000, 0x37490000, 0x374A0000, 0x374B0000, 0x374C0000, 0x374D0000, 0x374E0000, 0x374F0000, 
+                0x37500000, 0x37510000, 0x37520000, 0x37530000, 0x37540000, 0x37550000, 0x37560000, 0x37570000, 0x37580000, 0x37590000, 0x375A0000, 0x375B0000, 0x375C0000, 0x375D0000, 0x375E0000, 0x375F0000, 
+                0x37600000, 0x37610000, 0x37620000, 0x37630000, 0x37640000, 0x37650000, 0x37660000, 0x37670000, 0x37680000, 0x37690000, 0x376A0000, 0x376B0000, 0x376C0000, 0x376D0000, 0x376E0000, 0x376F0000, 
+                0x37700000, 0x37710000, 0x37720000, 0x37730000, 0x37740000, 0x37750000, 0x37760000, 0x37770000, 0x37780000, 0x37790000, 0x377A0000, 0x377B0000, 0x377C0000, 0x377D0000, 0x377E0000, 0x377F0000, 
+                0x37800000, 0x37808000, 0x37810000, 0x37818000, 0x37820000, 0x37828000, 0x37830000, 0x37838000, 0x37840000, 0x37848000, 0x37850000, 0x37858000, 0x37860000, 0x37868000, 0x37870000, 0x37878000, 
+                0x37880000, 0x37888000, 0x37890000, 0x37898000, 0x378A0000, 0x378A8000, 0x378B0000, 0x378B8000, 0x378C0000, 0x378C8000, 0x378D0000, 0x378D8000, 0x378E0000, 0x378E8000, 0x378F0000, 0x378F8000, 
+                0x37900000, 0x37908000, 0x37910000, 0x37918000, 0x37920000, 0x37928000, 0x37930000, 0x37938000, 0x37940000, 0x37948000, 0x37950000, 0x37958000, 0x37960000, 0x37968000, 0x37970000, 0x37978000, 
+                0x37980000, 0x37988000, 0x37990000, 0x37998000, 0x379A0000, 0x379A8000, 0x379B0000, 0x379B8000, 0x379C0000, 0x379C8000, 0x379D0000, 0x379D8000, 0x379E0000, 0x379E8000, 0x379F0000, 0x379F8000, 
+                0x37A00000, 0x37A08000, 0x37A10000, 0x37A18000, 0x37A20000, 0x37A28000, 0x37A30000, 0x37A38000, 0x37A40000, 0x37A48000, 0x37A50000, 0x37A58000, 0x37A60000, 0x37A68000, 0x37A70000, 0x37A78000, 
+                0x37A80000, 0x37A88000, 0x37A90000, 0x37A98000, 0x37AA0000, 0x37AA8000, 0x37AB0000, 0x37AB8000, 0x37AC0000, 0x37AC8000, 0x37AD0000, 0x37AD8000, 0x37AE0000, 0x37AE8000, 0x37AF0000, 0x37AF8000, 
+                0x37B00000, 0x37B08000, 0x37B10000, 0x37B18000, 0x37B20000, 0x37B28000, 0x37B30000, 0x37B38000, 0x37B40000, 0x37B48000, 0x37B50000, 0x37B58000, 0x37B60000, 0x37B68000, 0x37B70000, 0x37B78000, 
+                0x37B80000, 0x37B88000, 0x37B90000, 0x37B98000, 0x37BA0000, 0x37BA8000, 0x37BB0000, 0x37BB8000, 0x37BC0000, 0x37BC8000, 0x37BD0000, 0x37BD8000, 0x37BE0000, 0x37BE8000, 0x37BF0000, 0x37BF8000, 
+                0x37C00000, 0x37C08000, 0x37C10000, 0x37C18000, 0x37C20000, 0x37C28000, 0x37C30000, 0x37C38000, 0x37C40000, 0x37C48000, 0x37C50000, 0x37C58000, 0x37C60000, 0x37C68000, 0x37C70000, 0x37C78000, 
+                0x37C80000, 0x37C88000, 0x37C90000, 0x37C98000, 0x37CA0000, 0x37CA8000, 0x37CB0000, 0x37CB8000, 0x37CC0000, 0x37CC8000, 0x37CD0000, 0x37CD8000, 0x37CE0000, 0x37CE8000, 0x37CF0000, 0x37CF8000, 
+                0x37D00000, 0x37D08000, 0x37D10000, 0x37D18000, 0x37D20000, 0x37D28000, 0x37D30000, 0x37D38000, 0x37D40000, 0x37D48000, 0x37D50000, 0x37D58000, 0x37D60000, 0x37D68000, 0x37D70000, 0x37D78000, 
+                0x37D80000, 0x37D88000, 0x37D90000, 0x37D98000, 0x37DA0000, 0x37DA8000, 0x37DB0000, 0x37DB8000, 0x37DC0000, 0x37DC8000, 0x37DD0000, 0x37DD8000, 0x37DE0000, 0x37DE8000, 0x37DF0000, 0x37DF8000, 
+                0x37E00000, 0x37E08000, 0x37E10000, 0x37E18000, 0x37E20000, 0x37E28000, 0x37E30000, 0x37E38000, 0x37E40000, 0x37E48000, 0x37E50000, 0x37E58000, 0x37E60000, 0x37E68000, 0x37E70000, 0x37E78000, 
+                0x37E80000, 0x37E88000, 0x37E90000, 0x37E98000, 0x37EA0000, 0x37EA8000, 0x37EB0000, 0x37EB8000, 0x37EC0000, 0x37EC8000, 0x37ED0000, 0x37ED8000, 0x37EE0000, 0x37EE8000, 0x37EF0000, 0x37EF8000, 
+                0x37F00000, 0x37F08000, 0x37F10000, 0x37F18000, 0x37F20000, 0x37F28000, 0x37F30000, 0x37F38000, 0x37F40000, 0x37F48000, 0x37F50000, 0x37F58000, 0x37F60000, 0x37F68000, 0x37F70000, 0x37F78000, 
+                0x37F80000, 0x37F88000, 0x37F90000, 0x37F98000, 0x37FA0000, 0x37FA8000, 0x37FB0000, 0x37FB8000, 0x37FC0000, 0x37FC8000, 0x37FD0000, 0x37FD8000, 0x37FE0000, 0x37FE8000, 0x37FF0000, 0x37FF8000, 
+                0x38000000, 0x38004000, 0x38008000, 0x3800C000, 0x38010000, 0x38014000, 0x38018000, 0x3801C000, 0x38020000, 0x38024000, 0x38028000, 0x3802C000, 0x38030000, 0x38034000, 0x38038000, 0x3803C000, 
+                0x38040000, 0x38044000, 0x38048000, 0x3804C000, 0x38050000, 0x38054000, 0x38058000, 0x3805C000, 0x38060000, 0x38064000, 0x38068000, 0x3806C000, 0x38070000, 0x38074000, 0x38078000, 0x3807C000, 
+                0x38080000, 0x38084000, 0x38088000, 0x3808C000, 0x38090000, 0x38094000, 0x38098000, 0x3809C000, 0x380A0000, 0x380A4000, 0x380A8000, 0x380AC000, 0x380B0000, 0x380B4000, 0x380B8000, 0x380BC000, 
+                0x380C0000, 0x380C4000, 0x380C8000, 0x380CC000, 0x380D0000, 0x380D4000, 0x380D8000, 0x380DC000, 0x380E0000, 0x380E4000, 0x380E8000, 0x380EC000, 0x380F0000, 0x380F4000, 0x380F8000, 0x380FC000, 
+                0x38100000, 0x38104000, 0x38108000, 0x3810C000, 0x38110000, 0x38114000, 0x38118000, 0x3811C000, 0x38120000, 0x38124000, 0x38128000, 0x3812C000, 0x38130000, 0x38134000, 0x38138000, 0x3813C000, 
+                0x38140000, 0x38144000, 0x38148000, 0x3814C000, 0x38150000, 0x38154000, 0x38158000, 0x3815C000, 0x38160000, 0x38164000, 0x38168000, 0x3816C000, 0x38170000, 0x38174000, 0x38178000, 0x3817C000, 
+                0x38180000, 0x38184000, 0x38188000, 0x3818C000, 0x38190000, 0x38194000, 0x38198000, 0x3819C000, 0x381A0000, 0x381A4000, 0x381A8000, 0x381AC000, 0x381B0000, 0x381B4000, 0x381B8000, 0x381BC000, 
+                0x381C0000, 0x381C4000, 0x381C8000, 0x381CC000, 0x381D0000, 0x381D4000, 0x381D8000, 0x381DC000, 0x381E0000, 0x381E4000, 0x381E8000, 0x381EC000, 0x381F0000, 0x381F4000, 0x381F8000, 0x381FC000, 
+                0x38200000, 0x38204000, 0x38208000, 0x3820C000, 0x38210000, 0x38214000, 0x38218000, 0x3821C000, 0x38220000, 0x38224000, 0x38228000, 0x3822C000, 0x38230000, 0x38234000, 0x38238000, 0x3823C000, 
+                0x38240000, 0x38244000, 0x38248000, 0x3824C000, 0x38250000, 0x38254000, 0x38258000, 0x3825C000, 0x38260000, 0x38264000, 0x38268000, 0x3826C000, 0x38270000, 0x38274000, 0x38278000, 0x3827C000, 
+                0x38280000, 0x38284000, 0x38288000, 0x3828C000, 0x38290000, 0x38294000, 0x38298000, 0x3829C000, 0x382A0000, 0x382A4000, 0x382A8000, 0x382AC000, 0x382B0000, 0x382B4000, 0x382B8000, 0x382BC000, 
+                0x382C0000, 0x382C4000, 0x382C8000, 0x382CC000, 0x382D0000, 0x382D4000, 0x382D8000, 0x382DC000, 0x382E0000, 0x382E4000, 0x382E8000, 0x382EC000, 0x382F0000, 0x382F4000, 0x382F8000, 0x382FC000, 
+                0x38300000, 0x38304000, 0x38308000, 0x3830C000, 0x38310000, 0x38314000, 0x38318000, 0x3831C000, 0x38320000, 0x38324000, 0x38328000, 0x3832C000, 0x38330000, 0x38334000, 0x38338000, 0x3833C000, 
+                0x38340000, 0x38344000, 0x38348000, 0x3834C000, 0x38350000, 0x38354000, 0x38358000, 0x3835C000, 0x38360000, 0x38364000, 0x38368000, 0x3836C000, 0x38370000, 0x38374000, 0x38378000, 0x3837C000, 
+                0x38380000, 0x38384000, 0x38388000, 0x3838C000, 0x38390000, 0x38394000, 0x38398000, 0x3839C000, 0x383A0000, 0x383A4000, 0x383A8000, 0x383AC000, 0x383B0000, 0x383B4000, 0x383B8000, 0x383BC000, 
+                0x383C0000, 0x383C4000, 0x383C8000, 0x383CC000, 0x383D0000, 0x383D4000, 0x383D8000, 0x383DC000, 0x383E0000, 0x383E4000, 0x383E8000, 0x383EC000, 0x383F0000, 0x383F4000, 0x383F8000, 0x383FC000, 
+                0x38400000, 0x38404000, 0x38408000, 0x3840C000, 0x38410000, 0x38414000, 0x38418000, 0x3841C000, 0x38420000, 0x38424000, 0x38428000, 0x3842C000, 0x38430000, 0x38434000, 0x38438000, 0x3843C000, 
+                0x38440000, 0x38444000, 0x38448000, 0x3844C000, 0x38450000, 0x38454000, 0x38458000, 0x3845C000, 0x38460000, 0x38464000, 0x38468000, 0x3846C000, 0x38470000, 0x38474000, 0x38478000, 0x3847C000, 
+                0x38480000, 0x38484000, 0x38488000, 0x3848C000, 0x38490000, 0x38494000, 0x38498000, 0x3849C000, 0x384A0000, 0x384A4000, 0x384A8000, 0x384AC000, 0x384B0000, 0x384B4000, 0x384B8000, 0x384BC000, 
+                0x384C0000, 0x384C4000, 0x384C8000, 0x384CC000, 0x384D0000, 0x384D4000, 0x384D8000, 0x384DC000, 0x384E0000, 0x384E4000, 0x384E8000, 0x384EC000, 0x384F0000, 0x384F4000, 0x384F8000, 0x384FC000, 
+                0x38500000, 0x38504000, 0x38508000, 0x3850C000, 0x38510000, 0x38514000, 0x38518000, 0x3851C000, 0x38520000, 0x38524000, 0x38528000, 0x3852C000, 0x38530000, 0x38534000, 0x38538000, 0x3853C000, 
+                0x38540000, 0x38544000, 0x38548000, 0x3854C000, 0x38550000, 0x38554000, 0x38558000, 0x3855C000, 0x38560000, 0x38564000, 0x38568000, 0x3856C000, 0x38570000, 0x38574000, 0x38578000, 0x3857C000, 
+                0x38580000, 0x38584000, 0x38588000, 0x3858C000, 0x38590000, 0x38594000, 0x38598000, 0x3859C000, 0x385A0000, 0x385A4000, 0x385A8000, 0x385AC000, 0x385B0000, 0x385B4000, 0x385B8000, 0x385BC000, 
+                0x385C0000, 0x385C4000, 0x385C8000, 0x385CC000, 0x385D0000, 0x385D4000, 0x385D8000, 0x385DC000, 0x385E0000, 0x385E4000, 0x385E8000, 0x385EC000, 0x385F0000, 0x385F4000, 0x385F8000, 0x385FC000, 
+                0x38600000, 0x38604000, 0x38608000, 0x3860C000, 0x38610000, 0x38614000, 0x38618000, 0x3861C000, 0x38620000, 0x38624000, 0x38628000, 0x3862C000, 0x38630000, 0x38634000, 0x38638000, 0x3863C000, 
+                0x38640000, 0x38644000, 0x38648000, 0x3864C000, 0x38650000, 0x38654000, 0x38658000, 0x3865C000, 0x38660000, 0x38664000, 0x38668000, 0x3866C000, 0x38670000, 0x38674000, 0x38678000, 0x3867C000, 
+                0x38680000, 0x38684000, 0x38688000, 0x3868C000, 0x38690000, 0x38694000, 0x38698000, 0x3869C000, 0x386A0000, 0x386A4000, 0x386A8000, 0x386AC000, 0x386B0000, 0x386B4000, 0x386B8000, 0x386BC000, 
+                0x386C0000, 0x386C4000, 0x386C8000, 0x386CC000, 0x386D0000, 0x386D4000, 0x386D8000, 0x386DC000, 0x386E0000, 0x386E4000, 0x386E8000, 0x386EC000, 0x386F0000, 0x386F4000, 0x386F8000, 0x386FC000, 
+                0x38700000, 0x38704000, 0x38708000, 0x3870C000, 0x38710000, 0x38714000, 0x38718000, 0x3871C000, 0x38720000, 0x38724000, 0x38728000, 0x3872C000, 0x38730000, 0x38734000, 0x38738000, 0x3873C000, 
+                0x38740000, 0x38744000, 0x38748000, 0x3874C000, 0x38750000, 0x38754000, 0x38758000, 0x3875C000, 0x38760000, 0x38764000, 0x38768000, 0x3876C000, 0x38770000, 0x38774000, 0x38778000, 0x3877C000, 
+                0x38780000, 0x38784000, 0x38788000, 0x3878C000, 0x38790000, 0x38794000, 0x38798000, 0x3879C000, 0x387A0000, 0x387A4000, 0x387A8000, 0x387AC000, 0x387B0000, 0x387B4000, 0x387B8000, 0x387BC000, 
+                0x387C0000, 0x387C4000, 0x387C8000, 0x387CC000, 0x387D0000, 0x387D4000, 0x387D8000, 0x387DC000, 0x387E0000, 0x387E4000, 0x387E8000, 0x387EC000, 0x387F0000, 0x387F4000, 0x387F8000, 0x387FC000, 
+                0x38000000, 0x38002000, 0x38004000, 0x38006000, 0x38008000, 0x3800A000, 0x3800C000, 0x3800E000, 0x38010000, 0x38012000, 0x38014000, 0x38016000, 0x38018000, 0x3801A000, 0x3801C000, 0x3801E000, 
+                0x38020000, 0x38022000, 0x38024000, 0x38026000, 0x38028000, 0x3802A000, 0x3802C000, 0x3802E000, 0x38030000, 0x38032000, 0x38034000, 0x38036000, 0x38038000, 0x3803A000, 0x3803C000, 0x3803E000, 
+                0x38040000, 0x38042000, 0x38044000, 0x38046000, 0x38048000, 0x3804A000, 0x3804C000, 0x3804E000, 0x38050000, 0x38052000, 0x38054000, 0x38056000, 0x38058000, 0x3805A000, 0x3805C000, 0x3805E000, 
+                0x38060000, 0x38062000, 0x38064000, 0x38066000, 0x38068000, 0x3806A000, 0x3806C000, 0x3806E000, 0x38070000, 0x38072000, 0x38074000, 0x38076000, 0x38078000, 0x3807A000, 0x3807C000, 0x3807E000, 
+                0x38080000, 0x38082000, 0x38084000, 0x38086000, 0x38088000, 0x3808A000, 0x3808C000, 0x3808E000, 0x38090000, 0x38092000, 0x38094000, 0x38096000, 0x38098000, 0x3809A000, 0x3809C000, 0x3809E000, 
+                0x380A0000, 0x380A2000, 0x380A4000, 0x380A6000, 0x380A8000, 0x380AA000, 0x380AC000, 0x380AE000, 0x380B0000, 0x380B2000, 0x380B4000, 0x380B6000, 0x380B8000, 0x380BA000, 0x380BC000, 0x380BE000, 
+                0x380C0000, 0x380C2000, 0x380C4000, 0x380C6000, 0x380C8000, 0x380CA000, 0x380CC000, 0x380CE000, 0x380D0000, 0x380D2000, 0x380D4000, 0x380D6000, 0x380D8000, 0x380DA000, 0x380DC000, 0x380DE000, 
+                0x380E0000, 0x380E2000, 0x380E4000, 0x380E6000, 0x380E8000, 0x380EA000, 0x380EC000, 0x380EE000, 0x380F0000, 0x380F2000, 0x380F4000, 0x380F6000, 0x380F8000, 0x380FA000, 0x380FC000, 0x380FE000, 
+                0x38100000, 0x38102000, 0x38104000, 0x38106000, 0x38108000, 0x3810A000, 0x3810C000, 0x3810E000, 0x38110000, 0x38112000, 0x38114000, 0x38116000, 0x38118000, 0x3811A000, 0x3811C000, 0x3811E000, 
+                0x38120000, 0x38122000, 0x38124000, 0x38126000, 0x38128000, 0x3812A000, 0x3812C000, 0x3812E000, 0x38130000, 0x38132000, 0x38134000, 0x38136000, 0x38138000, 0x3813A000, 0x3813C000, 0x3813E000, 
+                0x38140000, 0x38142000, 0x38144000, 0x38146000, 0x38148000, 0x3814A000, 0x3814C000, 0x3814E000, 0x38150000, 0x38152000, 0x38154000, 0x38156000, 0x38158000, 0x3815A000, 0x3815C000, 0x3815E000, 
+                0x38160000, 0x38162000, 0x38164000, 0x38166000, 0x38168000, 0x3816A000, 0x3816C000, 0x3816E000, 0x38170000, 0x38172000, 0x38174000, 0x38176000, 0x38178000, 0x3817A000, 0x3817C000, 0x3817E000, 
+                0x38180000, 0x38182000, 0x38184000, 0x38186000, 0x38188000, 0x3818A000, 0x3818C000, 0x3818E000, 0x38190000, 0x38192000, 0x38194000, 0x38196000, 0x38198000, 0x3819A000, 0x3819C000, 0x3819E000, 
+                0x381A0000, 0x381A2000, 0x381A4000, 0x381A6000, 0x381A8000, 0x381AA000, 0x381AC000, 0x381AE000, 0x381B0000, 0x381B2000, 0x381B4000, 0x381B6000, 0x381B8000, 0x381BA000, 0x381BC000, 0x381BE000, 
+                0x381C0000, 0x381C2000, 0x381C4000, 0x381C6000, 0x381C8000, 0x381CA000, 0x381CC000, 0x381CE000, 0x381D0000, 0x381D2000, 0x381D4000, 0x381D6000, 0x381D8000, 0x381DA000, 0x381DC000, 0x381DE000, 
+                0x381E0000, 0x381E2000, 0x381E4000, 0x381E6000, 0x381E8000, 0x381EA000, 0x381EC000, 0x381EE000, 0x381F0000, 0x381F2000, 0x381F4000, 0x381F6000, 0x381F8000, 0x381FA000, 0x381FC000, 0x381FE000, 
+                0x38200000, 0x38202000, 0x38204000, 0x38206000, 0x38208000, 0x3820A000, 0x3820C000, 0x3820E000, 0x38210000, 0x38212000, 0x38214000, 0x38216000, 0x38218000, 0x3821A000, 0x3821C000, 0x3821E000, 
+                0x38220000, 0x38222000, 0x38224000, 0x38226000, 0x38228000, 0x3822A000, 0x3822C000, 0x3822E000, 0x38230000, 0x38232000, 0x38234000, 0x38236000, 0x38238000, 0x3823A000, 0x3823C000, 0x3823E000, 
+                0x38240000, 0x38242000, 0x38244000, 0x38246000, 0x38248000, 0x3824A000, 0x3824C000, 0x3824E000, 0x38250000, 0x38252000, 0x38254000, 0x38256000, 0x38258000, 0x3825A000, 0x3825C000, 0x3825E000, 
+                0x38260000, 0x38262000, 0x38264000, 0x38266000, 0x38268000, 0x3826A000, 0x3826C000, 0x3826E000, 0x38270000, 0x38272000, 0x38274000, 0x38276000, 0x38278000, 0x3827A000, 0x3827C000, 0x3827E000, 
+                0x38280000, 0x38282000, 0x38284000, 0x38286000, 0x38288000, 0x3828A000, 0x3828C000, 0x3828E000, 0x38290000, 0x38292000, 0x38294000, 0x38296000, 0x38298000, 0x3829A000, 0x3829C000, 0x3829E000, 
+                0x382A0000, 0x382A2000, 0x382A4000, 0x382A6000, 0x382A8000, 0x382AA000, 0x382AC000, 0x382AE000, 0x382B0000, 0x382B2000, 0x382B4000, 0x382B6000, 0x382B8000, 0x382BA000, 0x382BC000, 0x382BE000, 
+                0x382C0000, 0x382C2000, 0x382C4000, 0x382C6000, 0x382C8000, 0x382CA000, 0x382CC000, 0x382CE000, 0x382D0000, 0x382D2000, 0x382D4000, 0x382D6000, 0x382D8000, 0x382DA000, 0x382DC000, 0x382DE000, 
+                0x382E0000, 0x382E2000, 0x382E4000, 0x382E6000, 0x382E8000, 0x382EA000, 0x382EC000, 0x382EE000, 0x382F0000, 0x382F2000, 0x382F4000, 0x382F6000, 0x382F8000, 0x382FA000, 0x382FC000, 0x382FE000, 
+                0x38300000, 0x38302000, 0x38304000, 0x38306000, 0x38308000, 0x3830A000, 0x3830C000, 0x3830E000, 0x38310000, 0x38312000, 0x38314000, 0x38316000, 0x38318000, 0x3831A000, 0x3831C000, 0x3831E000, 
+                0x38320000, 0x38322000, 0x38324000, 0x38326000, 0x38328000, 0x3832A000, 0x3832C000, 0x3832E000, 0x38330000, 0x38332000, 0x38334000, 0x38336000, 0x38338000, 0x3833A000, 0x3833C000, 0x3833E000, 
+                0x38340000, 0x38342000, 0x38344000, 0x38346000, 0x38348000, 0x3834A000, 0x3834C000, 0x3834E000, 0x38350000, 0x38352000, 0x38354000, 0x38356000, 0x38358000, 0x3835A000, 0x3835C000, 0x3835E000, 
+                0x38360000, 0x38362000, 0x38364000, 0x38366000, 0x38368000, 0x3836A000, 0x3836C000, 0x3836E000, 0x38370000, 0x38372000, 0x38374000, 0x38376000, 0x38378000, 0x3837A000, 0x3837C000, 0x3837E000, 
+                0x38380000, 0x38382000, 0x38384000, 0x38386000, 0x38388000, 0x3838A000, 0x3838C000, 0x3838E000, 0x38390000, 0x38392000, 0x38394000, 0x38396000, 0x38398000, 0x3839A000, 0x3839C000, 0x3839E000, 
+                0x383A0000, 0x383A2000, 0x383A4000, 0x383A6000, 0x383A8000, 0x383AA000, 0x383AC000, 0x383AE000, 0x383B0000, 0x383B2000, 0x383B4000, 0x383B6000, 0x383B8000, 0x383BA000, 0x383BC000, 0x383BE000, 
+                0x383C0000, 0x383C2000, 0x383C4000, 0x383C6000, 0x383C8000, 0x383CA000, 0x383CC000, 0x383CE000, 0x383D0000, 0x383D2000, 0x383D4000, 0x383D6000, 0x383D8000, 0x383DA000, 0x383DC000, 0x383DE000, 
+                0x383E0000, 0x383E2000, 0x383E4000, 0x383E6000, 0x383E8000, 0x383EA000, 0x383EC000, 0x383EE000, 0x383F0000, 0x383F2000, 0x383F4000, 0x383F6000, 0x383F8000, 0x383FA000, 0x383FC000, 0x383FE000, 
+                0x38400000, 0x38402000, 0x38404000, 0x38406000, 0x38408000, 0x3840A000, 0x3840C000, 0x3840E000, 0x38410000, 0x38412000, 0x38414000, 0x38416000, 0x38418000, 0x3841A000, 0x3841C000, 0x3841E000, 
+                0x38420000, 0x38422000, 0x38424000, 0x38426000, 0x38428000, 0x3842A000, 0x3842C000, 0x3842E000, 0x38430000, 0x38432000, 0x38434000, 0x38436000, 0x38438000, 0x3843A000, 0x3843C000, 0x3843E000, 
+                0x38440000, 0x38442000, 0x38444000, 0x38446000, 0x38448000, 0x3844A000, 0x3844C000, 0x3844E000, 0x38450000, 0x38452000, 0x38454000, 0x38456000, 0x38458000, 0x3845A000, 0x3845C000, 0x3845E000, 
+                0x38460000, 0x38462000, 0x38464000, 0x38466000, 0x38468000, 0x3846A000, 0x3846C000, 0x3846E000, 0x38470000, 0x38472000, 0x38474000, 0x38476000, 0x38478000, 0x3847A000, 0x3847C000, 0x3847E000, 
+                0x38480000, 0x38482000, 0x38484000, 0x38486000, 0x38488000, 0x3848A000, 0x3848C000, 0x3848E000, 0x38490000, 0x38492000, 0x38494000, 0x38496000, 0x38498000, 0x3849A000, 0x3849C000, 0x3849E000, 
+                0x384A0000, 0x384A2000, 0x384A4000, 0x384A6000, 0x384A8000, 0x384AA000, 0x384AC000, 0x384AE000, 0x384B0000, 0x384B2000, 0x384B4000, 0x384B6000, 0x384B8000, 0x384BA000, 0x384BC000, 0x384BE000, 
+                0x384C0000, 0x384C2000, 0x384C4000, 0x384C6000, 0x384C8000, 0x384CA000, 0x384CC000, 0x384CE000, 0x384D0000, 0x384D2000, 0x384D4000, 0x384D6000, 0x384D8000, 0x384DA000, 0x384DC000, 0x384DE000, 
+                0x384E0000, 0x384E2000, 0x384E4000, 0x384E6000, 0x384E8000, 0x384EA000, 0x384EC000, 0x384EE000, 0x384F0000, 0x384F2000, 0x384F4000, 0x384F6000, 0x384F8000, 0x384FA000, 0x384FC000, 0x384FE000, 
+                0x38500000, 0x38502000, 0x38504000, 0x38506000, 0x38508000, 0x3850A000, 0x3850C000, 0x3850E000, 0x38510000, 0x38512000, 0x38514000, 0x38516000, 0x38518000, 0x3851A000, 0x3851C000, 0x3851E000, 
+                0x38520000, 0x38522000, 0x38524000, 0x38526000, 0x38528000, 0x3852A000, 0x3852C000, 0x3852E000, 0x38530000, 0x38532000, 0x38534000, 0x38536000, 0x38538000, 0x3853A000, 0x3853C000, 0x3853E000, 
+                0x38540000, 0x38542000, 0x38544000, 0x38546000, 0x38548000, 0x3854A000, 0x3854C000, 0x3854E000, 0x38550000, 0x38552000, 0x38554000, 0x38556000, 0x38558000, 0x3855A000, 0x3855C000, 0x3855E000, 
+                0x38560000, 0x38562000, 0x38564000, 0x38566000, 0x38568000, 0x3856A000, 0x3856C000, 0x3856E000, 0x38570000, 0x38572000, 0x38574000, 0x38576000, 0x38578000, 0x3857A000, 0x3857C000, 0x3857E000, 
+                0x38580000, 0x38582000, 0x38584000, 0x38586000, 0x38588000, 0x3858A000, 0x3858C000, 0x3858E000, 0x38590000, 0x38592000, 0x38594000, 0x38596000, 0x38598000, 0x3859A000, 0x3859C000, 0x3859E000, 
+                0x385A0000, 0x385A2000, 0x385A4000, 0x385A6000, 0x385A8000, 0x385AA000, 0x385AC000, 0x385AE000, 0x385B0000, 0x385B2000, 0x385B4000, 0x385B6000, 0x385B8000, 0x385BA000, 0x385BC000, 0x385BE000, 
+                0x385C0000, 0x385C2000, 0x385C4000, 0x385C6000, 0x385C8000, 0x385CA000, 0x385CC000, 0x385CE000, 0x385D0000, 0x385D2000, 0x385D4000, 0x385D6000, 0x385D8000, 0x385DA000, 0x385DC000, 0x385DE000, 
+                0x385E0000, 0x385E2000, 0x385E4000, 0x385E6000, 0x385E8000, 0x385EA000, 0x385EC000, 0x385EE000, 0x385F0000, 0x385F2000, 0x385F4000, 0x385F6000, 0x385F8000, 0x385FA000, 0x385FC000, 0x385FE000, 
+                0x38600000, 0x38602000, 0x38604000, 0x38606000, 0x38608000, 0x3860A000, 0x3860C000, 0x3860E000, 0x38610000, 0x38612000, 0x38614000, 0x38616000, 0x38618000, 0x3861A000, 0x3861C000, 0x3861E000, 
+                0x38620000, 0x38622000, 0x38624000, 0x38626000, 0x38628000, 0x3862A000, 0x3862C000, 0x3862E000, 0x38630000, 0x38632000, 0x38634000, 0x38636000, 0x38638000, 0x3863A000, 0x3863C000, 0x3863E000, 
+                0x38640000, 0x38642000, 0x38644000, 0x38646000, 0x38648000, 0x3864A000, 0x3864C000, 0x3864E000, 0x38650000, 0x38652000, 0x38654000, 0x38656000, 0x38658000, 0x3865A000, 0x3865C000, 0x3865E000, 
+                0x38660000, 0x38662000, 0x38664000, 0x38666000, 0x38668000, 0x3866A000, 0x3866C000, 0x3866E000, 0x38670000, 0x38672000, 0x38674000, 0x38676000, 0x38678000, 0x3867A000, 0x3867C000, 0x3867E000, 
+                0x38680000, 0x38682000, 0x38684000, 0x38686000, 0x38688000, 0x3868A000, 0x3868C000, 0x3868E000, 0x38690000, 0x38692000, 0x38694000, 0x38696000, 0x38698000, 0x3869A000, 0x3869C000, 0x3869E000, 
+                0x386A0000, 0x386A2000, 0x386A4000, 0x386A6000, 0x386A8000, 0x386AA000, 0x386AC000, 0x386AE000, 0x386B0000, 0x386B2000, 0x386B4000, 0x386B6000, 0x386B8000, 0x386BA000, 0x386BC000, 0x386BE000, 
+                0x386C0000, 0x386C2000, 0x386C4000, 0x386C6000, 0x386C8000, 0x386CA000, 0x386CC000, 0x386CE000, 0x386D0000, 0x386D2000, 0x386D4000, 0x386D6000, 0x386D8000, 0x386DA000, 0x386DC000, 0x386DE000, 
+                0x386E0000, 0x386E2000, 0x386E4000, 0x386E6000, 0x386E8000, 0x386EA000, 0x386EC000, 0x386EE000, 0x386F0000, 0x386F2000, 0x386F4000, 0x386F6000, 0x386F8000, 0x386FA000, 0x386FC000, 0x386FE000, 
+                0x38700000, 0x38702000, 0x38704000, 0x38706000, 0x38708000, 0x3870A000, 0x3870C000, 0x3870E000, 0x38710000, 0x38712000, 0x38714000, 0x38716000, 0x38718000, 0x3871A000, 0x3871C000, 0x3871E000, 
+                0x38720000, 0x38722000, 0x38724000, 0x38726000, 0x38728000, 0x3872A000, 0x3872C000, 0x3872E000, 0x38730000, 0x38732000, 0x38734000, 0x38736000, 0x38738000, 0x3873A000, 0x3873C000, 0x3873E000, 
+                0x38740000, 0x38742000, 0x38744000, 0x38746000, 0x38748000, 0x3874A000, 0x3874C000, 0x3874E000, 0x38750000, 0x38752000, 0x38754000, 0x38756000, 0x38758000, 0x3875A000, 0x3875C000, 0x3875E000, 
+                0x38760000, 0x38762000, 0x38764000, 0x38766000, 0x38768000, 0x3876A000, 0x3876C000, 0x3876E000, 0x38770000, 0x38772000, 0x38774000, 0x38776000, 0x38778000, 0x3877A000, 0x3877C000, 0x3877E000, 
+                0x38780000, 0x38782000, 0x38784000, 0x38786000, 0x38788000, 0x3878A000, 0x3878C000, 0x3878E000, 0x38790000, 0x38792000, 0x38794000, 0x38796000, 0x38798000, 0x3879A000, 0x3879C000, 0x3879E000, 
+                0x387A0000, 0x387A2000, 0x387A4000, 0x387A6000, 0x387A8000, 0x387AA000, 0x387AC000, 0x387AE000, 0x387B0000, 0x387B2000, 0x387B4000, 0x387B6000, 0x387B8000, 0x387BA000, 0x387BC000, 0x387BE000, 
+                0x387C0000, 0x387C2000, 0x387C4000, 0x387C6000, 0x387C8000, 0x387CA000, 0x387CC000, 0x387CE000, 0x387D0000, 0x387D2000, 0x387D4000, 0x387D6000, 0x387D8000, 0x387DA000, 0x387DC000, 0x387DE000, 
+                0x387E0000, 0x387E2000, 0x387E4000, 0x387E6000, 0x387E8000, 0x387EA000, 0x387EC000, 0x387EE000, 0x387F0000, 0x387F2000, 0x387F4000, 0x387F6000, 0x387F8000, 0x387FA000, 0x387FC000, 0x387FE000 };
+            static const uint32 exponent_table[64] = { 
+                0x00000000, 0x00800000, 0x01000000, 0x01800000, 0x02000000, 0x02800000, 0x03000000, 0x03800000, 0x04000000, 0x04800000, 0x05000000, 0x05800000, 0x06000000, 0x06800000, 0x07000000, 0x07800000, 
+                0x08000000, 0x08800000, 0x09000000, 0x09800000, 0x0A000000, 0x0A800000, 0x0B000000, 0x0B800000, 0x0C000000, 0x0C800000, 0x0D000000, 0x0D800000, 0x0E000000, 0x0E800000, 0x0F000000, 0x47800000, 
+                0x80000000, 0x80800000, 0x81000000, 0x81800000, 0x82000000, 0x82800000, 0x83000000, 0x83800000, 0x84000000, 0x84800000, 0x85000000, 0x85800000, 0x86000000, 0x86800000, 0x87000000, 0x87800000, 
+                0x88000000, 0x88800000, 0x89000000, 0x89800000, 0x8A000000, 0x8A800000, 0x8B000000, 0x8B800000, 0x8C000000, 0x8C800000, 0x8D000000, 0x8D800000, 0x8E000000, 0x8E800000, 0x8F000000, 0xC7800000 };
+            static const unsigned short offset_table[64] = { 
+                   0, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 
+                   0, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024, 1024 };
+            uint32 bits = mantissa_table[offset_table[value>>10]+(value&0x3FF)] + exponent_table[value>>10];
 //			return *reinterpret_cast<float*>(&bits);			//violating strict aliasing!
-			float out;
-			std::memcpy(&out, &bits, sizeof(float));
-			return out;
-		}
-
-		/// Convert half-precision to IEEE double-precision.
-		/// \param value binary representation of half-precision value
-		/// \return double-precision value
-		inline double half2float_impl(uint16 value, double, true_type)
-		{
-			typedef bits<float>::type uint32;
-			typedef bits<double>::type uint64;
-			uint32 hi = static_cast<uint32>(value&0x8000) << 16;
-			int abs = value & 0x7FFF;
-			if(abs)
-			{
-				hi |= 0x3F000000 << static_cast<unsigned>(abs>=0x7C00);
-				for(; abs<0x400; abs<<=1,hi-=0x100000) ;
-				hi += static_cast<uint32>(abs) << 10;
-			}
-			uint64 bits = static_cast<uint64>(hi) << 32;
+            float out;
+            std::memcpy(&out, &bits, sizeof(float));
+            return out;
+        }
+
+        /// Convert half-precision to IEEE double-precision.
+        /// \param value binary representation of half-precision value
+        /// \return double-precision value
+        inline double half2float_impl(uint16 value, double, true_type)
+        {
+            typedef bits<float>::type uint32;
+            typedef bits<double>::type uint64;
+            uint32 hi = static_cast<uint32>(value&0x8000) << 16;
+            int abs = value & 0x7FFF;
+            if(abs)
+            {
+                hi |= 0x3F000000 << static_cast<unsigned>(abs>=0x7C00);
+                for(; abs<0x400; abs<<=1,hi-=0x100000) ;
+                hi += static_cast<uint32>(abs) << 10;
+            }
+            uint64 bits = static_cast<uint64>(hi) << 32;
 //			return *reinterpret_cast<double*>(&bits);			//violating strict aliasing!
-			double out;
-			std::memcpy(&out, &bits, sizeof(double));
-			return out;
-		}
-
-		/// Convert half-precision to non-IEEE floating point.
-		/// \tparam T type to convert to (builtin integer type)
-		/// \param value binary representation of half-precision value
-		/// \return floating point value
-		template<typename T> T half2float_impl(uint16 value, T, ...)
-		{
-			T out;
-			int abs = value & 0x7FFF;
-			if(abs > 0x7C00)
-				out = std::numeric_limits<T>::has_quiet_NaN ? std::numeric_limits<T>::quiet_NaN() : T();
-			else if(abs == 0x7C00)
-				out = std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : std::numeric_limits<T>::max();
-			else if(abs > 0x3FF)
-				out = std::ldexp(static_cast<T>((abs&0x3FF)|0x400), (abs>>10)-25);
-			else
-				out = std::ldexp(static_cast<T>(abs), -24);
-			return (value&0x8000) ? -out : out;
-		}
-
-		/// Convert half-precision to floating point.
-		/// \tparam T type to convert to (builtin integer type)
-		/// \param value binary representation of half-precision value
-		/// \return floating point value
-		template<typename T> T half2float(uint16 value)
-		{
-			return half2float_impl(value, T(), bool_type<std::numeric_limits<T>::is_iec559&&sizeof(typename bits<T>::type)==sizeof(T)>());
-		}
-
-		/// Convert half-precision floating point to integer.
-		/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
-		/// \tparam E `true` for round to even, `false` for round away from zero
-		/// \tparam T type to convert to (buitlin integer type with at least 16 bits precision, excluding any implicit sign bits)
-		/// \param value binary representation of half-precision value
-		/// \return integral value
-		template<std::float_round_style R,bool E,typename T> T half2int_impl(uint16 value)
-		{
-		#if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
-			static_assert(std::is_integral<T>::value, "half to int conversion only supports builtin integer types");
-		#endif
-			unsigned int e = value & 0x7FFF;
-			if(e >= 0x7C00)
-				return (value&0x8000) ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
-			if(e < 0x3800)
-			{
-				if(R == std::round_toward_infinity)
-					return T(~(value>>15)&(e!=0));
-				else if(R == std::round_toward_neg_infinity)
-					return -T(value>0x8000);
-				return T();
-			}
-			unsigned int m = (value&0x3FF) | 0x400;
-			e >>= 10;
-			if(e < 25)
-			{
-				if(R == std::round_to_nearest)
-					m += (1<<(24-e)) - (~(m>>(25-e))&E);
-				else if(R == std::round_toward_infinity)
-					m += ((value>>15)-1) & ((1<<(25-e))-1U);
-				else if(R == std::round_toward_neg_infinity)
-					m += -(value>>15) & ((1<<(25-e))-1U);
-				m >>= 25 - e;
-			}
-			else
-				m <<= e - 25;
-			return (value&0x8000) ? -static_cast<T>(m) : static_cast<T>(m);
-		}
-
-		/// Convert half-precision floating point to integer.
-		/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
-		/// \tparam T type to convert to (buitlin integer type with at least 16 bits precision, excluding any implicit sign bits)
-		/// \param value binary representation of half-precision value
-		/// \return integral value
-		template<std::float_round_style R,typename T> T half2int(uint16 value) { return half2int_impl<R,HALF_ROUND_TIES_TO_EVEN,T>(value); }
-
-		/// Convert half-precision floating point to integer using round-to-nearest-away-from-zero.
-		/// \tparam T type to convert to (buitlin integer type with at least 16 bits precision, excluding any implicit sign bits)
-		/// \param value binary representation of half-precision value
-		/// \return integral value
-		template<typename T> T half2int_up(uint16 value) { return half2int_impl<std::round_to_nearest,0,T>(value); }
-
-		/// Round half-precision number to nearest integer value.
-		/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
-		/// \tparam E `true` for round to even, `false` for round away from zero
-		/// \param value binary representation of half-precision value
-		/// \return half-precision bits for nearest integral value
-		template<std::float_round_style R,bool E> uint16 round_half_impl(uint16 value)
-		{
-			unsigned int e = value & 0x7FFF;
-			uint16 result = value;
-			if(e < 0x3C00)
-			{
-				result &= 0x8000;
-				if(R == std::round_to_nearest)
-					result |= 0x3C00U & -(e>=(0x3800+E));
-				else if(R == std::round_toward_infinity)
-					result |= 0x3C00U & -(~(value>>15)&(e!=0));
-				else if(R == std::round_toward_neg_infinity)
-					result |= 0x3C00U & -(value>0x8000);
-			}
-			else if(e < 0x6400)
-			{
-				e = 25 - (e>>10);
-				unsigned int mask = (1<<e) - 1;
-				if(R == std::round_to_nearest)
-					result += (1<<(e-1)) - (~(result>>e)&E);
-				else if(R == std::round_toward_infinity)
-					result += mask & ((value>>15)-1);
-				else if(R == std::round_toward_neg_infinity)
-					result += mask & -(value>>15);
-				result &= ~mask;
-			}
-			return result;
-		}
-
-		/// Round half-precision number to nearest integer value.
-		/// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
-		/// \param value binary representation of half-precision value
-		/// \return half-precision bits for nearest integral value
-		template<std::float_round_style R> uint16 round_half(uint16 value) { return round_half_impl<R,HALF_ROUND_TIES_TO_EVEN>(value); }
-
-		/// Round half-precision number to nearest integer value using round-to-nearest-away-from-zero.
-		/// \param value binary representation of half-precision value
-		/// \return half-precision bits for nearest integral value
-		inline uint16 round_half_up(uint16 value) { return round_half_impl<std::round_to_nearest,0>(value); }
-		/// \}
-
-		struct functions;
-		template<typename> struct unary_specialized;
-		template<typename,typename> struct binary_specialized;
-		template<typename,typename,std::float_round_style> struct half_caster;
-	}
-
-	/// Half-precision floating point type.
-	/// This class implements an IEEE-conformant half-precision floating point type with the usual arithmetic operators and 
-	/// conversions. It is implicitly convertible to single-precision floating point, which makes artihmetic expressions and 
-	/// functions with mixed-type operands to be of the most precise operand type. Additionally all arithmetic operations 
-	/// (and many mathematical functions) are carried out in single-precision internally. All conversions from single- to 
-	/// half-precision are done using the library's default rounding mode, but temporary results inside chained arithmetic 
-	/// expressions are kept in single-precision as long as possible (while of course still maintaining a strong half-precision type).
-	///
-	/// According to the C++98/03 definition, the half type is not a POD type. But according to C++11's less strict and 
-	/// extended definitions it is both a standard layout type and a trivially copyable type (even if not a POD type), which 
-	/// means it can be standard-conformantly copied using raw binary copies. But in this context some more words about the 
-	/// actual size of the type. Although the half is representing an IEEE 16-bit type, it does not neccessarily have to be of 
-	/// exactly 16-bits size. But on any reasonable implementation the actual binary representation of this type will most 
-	/// probably not ivolve any additional "magic" or padding beyond the simple binary representation of the underlying 16-bit 
-	/// IEEE number, even if not strictly guaranteed by the standard. But even then it only has an actual size of 16 bits if 
-	/// your C++ implementation supports an unsigned integer type of exactly 16 bits width. But this should be the case on 
-	/// nearly any reasonable platform.
-	///
-	/// So if your C++ implementation is not totally exotic or imposes special alignment requirements, it is a reasonable 
-	/// assumption that the data of a half is just comprised of the 2 bytes of the underlying IEEE representation.
-	class half
-	{
-		friend struct detail::functions;
-		friend struct detail::unary_specialized<half>;
-		friend struct detail::binary_specialized<half,half>;
-		template<typename,typename,std::float_round_style> friend struct detail::half_caster;
-		friend class std::numeric_limits<half>;
-	#if HALF_ENABLE_CPP11_HASH
-		friend struct std::hash<half>;
-	#endif
-	#if HALF_ENABLE_CPP11_USER_LITERALS
-		friend half literal::operator""_h(long double);
-	#endif
-
-	public:
-		/// Default constructor.
-		/// This initializes the half to 0. Although this does not match the builtin types' default-initialization semantics 
-		/// and may be less efficient than no initialization, it is needed to provide proper value-initialization semantics.
-		HALF_CONSTEXPR half() HALF_NOEXCEPT : data_() {}
-
-		/// Copy constructor.
-		/// \tparam T type of concrete half expression
-		/// \param rhs half expression to copy from
-		half(detail::expr rhs) : data_(detail::float2half<round_style>(static_cast<float>(rhs))) {}
-
-		/// Conversion constructor.
-		/// \param rhs float to convert
-		explicit half(float rhs) : data_(detail::float2half<round_style>(rhs)) {}
-	
-		/// Conversion to single-precision.
-		/// \return single precision value representing expression value
-		operator float() const { return detail::half2float<float>(data_); }
-
-		/// Assignment operator.
-		/// \tparam T type of concrete half expression
-		/// \param rhs half expression to copy from
-		/// \return reference to this half
-		half& operator=(detail::expr rhs) { return *this = static_cast<float>(rhs); }
-
-		/// Arithmetic assignment.
-		/// \tparam T type of concrete half expression
-		/// \param rhs half expression to add
-		/// \return reference to this half
-		template<typename T> typename detail::enable<half&,T>::type operator+=(T rhs) { return *this += static_cast<float>(rhs); }
-
-		/// Arithmetic assignment.
-		/// \tparam T type of concrete half expression
-		/// \param rhs half expression to subtract
-		/// \return reference to this half
-		template<typename T> typename detail::enable<half&,T>::type operator-=(T rhs) { return *this -= static_cast<float>(rhs); }
-
-		/// Arithmetic assignment.
-		/// \tparam T type of concrete half expression
-		/// \param rhs half expression to multiply with
-		/// \return reference to this half
-		template<typename T> typename detail::enable<half&,T>::type operator*=(T rhs) { return *this *= static_cast<float>(rhs); }
-
-		/// Arithmetic assignment.
-		/// \tparam T type of concrete half expression
-		/// \param rhs half expression to divide by
-		/// \return reference to this half
-		template<typename T> typename detail::enable<half&,T>::type operator/=(T rhs) { return *this /= static_cast<float>(rhs); }
-
-		/// Assignment operator.
-		/// \param rhs single-precision value to copy from
-		/// \return reference to this half
-		half& operator=(float rhs) { data_ = detail::float2half<round_style>(rhs); return *this; }
-
-		/// Arithmetic assignment.
-		/// \param rhs single-precision value to add
-		/// \return reference to this half
-		half& operator+=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float<float>(data_)+rhs); return *this; }
-
-		/// Arithmetic assignment.
-		/// \param rhs single-precision value to subtract
-		/// \return reference to this half
-		half& operator-=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float<float>(data_)-rhs); return *this; }
-
-		/// Arithmetic assignment.
-		/// \param rhs single-precision value to multiply with
-		/// \return reference to this half
-		half& operator*=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float<float>(data_)*rhs); return *this; }
-
-		/// Arithmetic assignment.
-		/// \param rhs single-precision value to divide by
-		/// \return reference to this half
-		half& operator/=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float<float>(data_)/rhs); return *this; }
-
-		/// Prefix increment.
-		/// \return incremented half value
-		half& operator++() { return *this += 1.0f; }
-
-		/// Prefix decrement.
-		/// \return decremented half value
-		half& operator--() { return *this -= 1.0f; }
-
-		/// Postfix increment.
-		/// \return non-incremented half value
-		half operator++(int) { half out(*this); ++*this; return out; }
-
-		/// Postfix decrement.
-		/// \return non-decremented half value
-		half operator--(int) { half out(*this); --*this; return out; }
-	
-	private:
-		/// Rounding mode to use
-		static const std::float_round_style round_style = (std::float_round_style)(HALF_ROUND_STYLE);
-
-		/// Constructor.
-		/// \param bits binary representation to set half to
-		HALF_CONSTEXPR half(detail::binary_t, detail::uint16 bits) HALF_NOEXCEPT : data_(bits) {}
-
-		/// Internal binary representation
-		detail::uint16 data_;
-	};
+            double out;
+            std::memcpy(&out, &bits, sizeof(double));
+            return out;
+        }
+
+        /// Convert half-precision to non-IEEE floating point.
+        /// \tparam T type to convert to (builtin integer type)
+        /// \param value binary representation of half-precision value
+        /// \return floating point value
+        template<typename T> T half2float_impl(uint16 value, T, ...)
+        {
+            T out;
+            int abs = value & 0x7FFF;
+            if(abs > 0x7C00)
+                out = std::numeric_limits<T>::has_quiet_NaN ? std::numeric_limits<T>::quiet_NaN() : T();
+            else if(abs == 0x7C00)
+                out = std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity() : std::numeric_limits<T>::max();
+            else if(abs > 0x3FF)
+                out = std::ldexp(static_cast<T>((abs&0x3FF)|0x400), (abs>>10)-25);
+            else
+                out = std::ldexp(static_cast<T>(abs), -24);
+            return (value&0x8000) ? -out : out;
+        }
+
+        /// Convert half-precision to floating point.
+        /// \tparam T type to convert to (builtin integer type)
+        /// \param value binary representation of half-precision value
+        /// \return floating point value
+        template<typename T> T half2float(uint16 value)
+        {
+            return half2float_impl(value, T(), bool_type<std::numeric_limits<T>::is_iec559&&sizeof(typename bits<T>::type)==sizeof(T)>());
+        }
+
+        /// Convert half-precision floating point to integer.
+        /// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
+        /// \tparam E `true` for round to even, `false` for round away from zero
+        /// \tparam T type to convert to (buitlin integer type with at least 16 bits precision, excluding any implicit sign bits)
+        /// \param value binary representation of half-precision value
+        /// \return integral value
+        template<std::float_round_style R,bool E,typename T> T half2int_impl(uint16 value)
+        {
+        #if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
+            static_assert(std::is_integral<T>::value, "half to int conversion only supports builtin integer types");
+        #endif
+            unsigned int e = value & 0x7FFF;
+            if(e >= 0x7C00)
+                return (value&0x8000) ? std::numeric_limits<T>::min() : std::numeric_limits<T>::max();
+            if(e < 0x3800)
+            {
+                if(R == std::round_toward_infinity)
+                    return T(~(value>>15)&(e!=0));
+                else if(R == std::round_toward_neg_infinity)
+                    return -T(value>0x8000);
+                return T();
+            }
+            unsigned int m = (value&0x3FF) | 0x400;
+            e >>= 10;
+            if(e < 25)
+            {
+                if(R == std::round_to_nearest)
+                    m += (1<<(24-e)) - (~(m>>(25-e))&E);
+                else if(R == std::round_toward_infinity)
+                    m += ((value>>15)-1) & ((1<<(25-e))-1U);
+                else if(R == std::round_toward_neg_infinity)
+                    m += -(value>>15) & ((1<<(25-e))-1U);
+                m >>= 25 - e;
+            }
+            else
+                m <<= e - 25;
+            return (value&0x8000) ? -static_cast<T>(m) : static_cast<T>(m);
+        }
+
+        /// Convert half-precision floating point to integer.
+        /// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
+        /// \tparam T type to convert to (buitlin integer type with at least 16 bits precision, excluding any implicit sign bits)
+        /// \param value binary representation of half-precision value
+        /// \return integral value
+        template<std::float_round_style R,typename T> T half2int(uint16 value) { return half2int_impl<R,HALF_ROUND_TIES_TO_EVEN,T>(value); }
+
+        /// Convert half-precision floating point to integer using round-to-nearest-away-from-zero.
+        /// \tparam T type to convert to (buitlin integer type with at least 16 bits precision, excluding any implicit sign bits)
+        /// \param value binary representation of half-precision value
+        /// \return integral value
+        template<typename T> T half2int_up(uint16 value) { return half2int_impl<std::round_to_nearest,0,T>(value); }
+
+        /// Round half-precision number to nearest integer value.
+        /// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
+        /// \tparam E `true` for round to even, `false` for round away from zero
+        /// \param value binary representation of half-precision value
+        /// \return half-precision bits for nearest integral value
+        template<std::float_round_style R,bool E> uint16 round_half_impl(uint16 value)
+        {
+            unsigned int e = value & 0x7FFF;
+            uint16 result = value;
+            if(e < 0x3C00)
+            {
+                result &= 0x8000;
+                if(R == std::round_to_nearest)
+                    result |= 0x3C00U & -(e>=(0x3800+E));
+                else if(R == std::round_toward_infinity)
+                    result |= 0x3C00U & -(~(value>>15)&(e!=0));
+                else if(R == std::round_toward_neg_infinity)
+                    result |= 0x3C00U & -(value>0x8000);
+            }
+            else if(e < 0x6400)
+            {
+                e = 25 - (e>>10);
+                unsigned int mask = (1<<e) - 1;
+                if(R == std::round_to_nearest)
+                    result += (1<<(e-1)) - (~(result>>e)&E);
+                else if(R == std::round_toward_infinity)
+                    result += mask & ((value>>15)-1);
+                else if(R == std::round_toward_neg_infinity)
+                    result += mask & -(value>>15);
+                result &= ~mask;
+            }
+            return result;
+        }
+
+        /// Round half-precision number to nearest integer value.
+        /// \tparam R rounding mode to use, `std::round_indeterminate` for fastest rounding
+        /// \param value binary representation of half-precision value
+        /// \return half-precision bits for nearest integral value
+        template<std::float_round_style R> uint16 round_half(uint16 value) { return round_half_impl<R,HALF_ROUND_TIES_TO_EVEN>(value); }
+
+        /// Round half-precision number to nearest integer value using round-to-nearest-away-from-zero.
+        /// \param value binary representation of half-precision value
+        /// \return half-precision bits for nearest integral value
+        inline uint16 round_half_up(uint16 value) { return round_half_impl<std::round_to_nearest,0>(value); }
+        /// \}
+
+        struct functions;
+        template<typename> struct unary_specialized;
+        template<typename,typename> struct binary_specialized;
+        template<typename,typename,std::float_round_style> struct half_caster;
+    }
+
+    /// Half-precision floating point type.
+    /// This class implements an IEEE-conformant half-precision floating point type with the usual arithmetic operators and 
+    /// conversions. It is implicitly convertible to single-precision floating point, which makes artihmetic expressions and 
+    /// functions with mixed-type operands to be of the most precise operand type. Additionally all arithmetic operations 
+    /// (and many mathematical functions) are carried out in single-precision internally. All conversions from single- to 
+    /// half-precision are done using the library's default rounding mode, but temporary results inside chained arithmetic 
+    /// expressions are kept in single-precision as long as possible (while of course still maintaining a strong half-precision type).
+    ///
+    /// According to the C++98/03 definition, the half type is not a POD type. But according to C++11's less strict and 
+    /// extended definitions it is both a standard layout type and a trivially copyable type (even if not a POD type), which 
+    /// means it can be standard-conformantly copied using raw binary copies. But in this context some more words about the 
+    /// actual size of the type. Although the half is representing an IEEE 16-bit type, it does not neccessarily have to be of 
+    /// exactly 16-bits size. But on any reasonable implementation the actual binary representation of this type will most 
+    /// probably not ivolve any additional "magic" or padding beyond the simple binary representation of the underlying 16-bit 
+    /// IEEE number, even if not strictly guaranteed by the standard. But even then it only has an actual size of 16 bits if 
+    /// your C++ implementation supports an unsigned integer type of exactly 16 bits width. But this should be the case on 
+    /// nearly any reasonable platform.
+    ///
+    /// So if your C++ implementation is not totally exotic or imposes special alignment requirements, it is a reasonable 
+    /// assumption that the data of a half is just comprised of the 2 bytes of the underlying IEEE representation.
+    class half
+    {
+        friend struct detail::functions;
+        friend struct detail::unary_specialized<half>;
+        friend struct detail::binary_specialized<half,half>;
+        template<typename,typename,std::float_round_style> friend struct detail::half_caster;
+        friend class std::numeric_limits<half>;
+    #if HALF_ENABLE_CPP11_HASH
+        friend struct std::hash<half>;
+    #endif
+    #if HALF_ENABLE_CPP11_USER_LITERALS
+        friend half literal::operator""_h(long double);
+    #endif
+
+    public:
+        /// Default constructor.
+        /// This initializes the half to 0. Although this does not match the builtin types' default-initialization semantics 
+        /// and may be less efficient than no initialization, it is needed to provide proper value-initialization semantics.
+        HALF_CONSTEXPR half() HALF_NOEXCEPT : data_() {}
+
+        /// Copy constructor.
+        /// \tparam T type of concrete half expression
+        /// \param rhs half expression to copy from
+        half(detail::expr rhs) : data_(detail::float2half<round_style>(static_cast<float>(rhs))) {}
+
+        /// Conversion constructor.
+        /// \param rhs float to convert
+        explicit half(float rhs) : data_(detail::float2half<round_style>(rhs)) {}
+    
+        /// Conversion to single-precision.
+        /// \return single precision value representing expression value
+        operator float() const { return detail::half2float<float>(data_); }
+
+        /// Assignment operator.
+        /// \tparam T type of concrete half expression
+        /// \param rhs half expression to copy from
+        /// \return reference to this half
+        half& operator=(detail::expr rhs) { return *this = static_cast<float>(rhs); }
+
+        /// Arithmetic assignment.
+        /// \tparam T type of concrete half expression
+        /// \param rhs half expression to add
+        /// \return reference to this half
+        template<typename T> typename detail::enable<half&,T>::type operator+=(T rhs) { return *this += static_cast<float>(rhs); }
+
+        /// Arithmetic assignment.
+        /// \tparam T type of concrete half expression
+        /// \param rhs half expression to subtract
+        /// \return reference to this half
+        template<typename T> typename detail::enable<half&,T>::type operator-=(T rhs) { return *this -= static_cast<float>(rhs); }
+
+        /// Arithmetic assignment.
+        /// \tparam T type of concrete half expression
+        /// \param rhs half expression to multiply with
+        /// \return reference to this half
+        template<typename T> typename detail::enable<half&,T>::type operator*=(T rhs) { return *this *= static_cast<float>(rhs); }
+
+        /// Arithmetic assignment.
+        /// \tparam T type of concrete half expression
+        /// \param rhs half expression to divide by
+        /// \return reference to this half
+        template<typename T> typename detail::enable<half&,T>::type operator/=(T rhs) { return *this /= static_cast<float>(rhs); }
+
+        /// Assignment operator.
+        /// \param rhs single-precision value to copy from
+        /// \return reference to this half
+        half& operator=(float rhs) { data_ = detail::float2half<round_style>(rhs); return *this; }
+
+        /// Arithmetic assignment.
+        /// \param rhs single-precision value to add
+        /// \return reference to this half
+        half& operator+=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float<float>(data_)+rhs); return *this; }
+
+        /// Arithmetic assignment.
+        /// \param rhs single-precision value to subtract
+        /// \return reference to this half
+        half& operator-=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float<float>(data_)-rhs); return *this; }
+
+        /// Arithmetic assignment.
+        /// \param rhs single-precision value to multiply with
+        /// \return reference to this half
+        half& operator*=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float<float>(data_)*rhs); return *this; }
+
+        /// Arithmetic assignment.
+        /// \param rhs single-precision value to divide by
+        /// \return reference to this half
+        half& operator/=(float rhs) { data_ = detail::float2half<round_style>(detail::half2float<float>(data_)/rhs); return *this; }
+
+        /// Prefix increment.
+        /// \return incremented half value
+        half& operator++() { return *this += 1.0f; }
+
+        /// Prefix decrement.
+        /// \return decremented half value
+        half& operator--() { return *this -= 1.0f; }
+
+        /// Postfix increment.
+        /// \return non-incremented half value
+        half operator++(int) { half out(*this); ++*this; return out; }
+
+        /// Postfix decrement.
+        /// \return non-decremented half value
+        half operator--(int) { half out(*this); --*this; return out; }
+    
+    private:
+        /// Rounding mode to use
+        static const std::float_round_style round_style = (std::float_round_style)(HALF_ROUND_STYLE);
+
+        /// Constructor.
+        /// \param bits binary representation to set half to
+        HALF_CONSTEXPR half(detail::binary_t, detail::uint16 bits) HALF_NOEXCEPT : data_(bits) {}
+
+        /// Internal binary representation
+        detail::uint16 data_;
+    };
 
 #if HALF_ENABLE_CPP11_USER_LITERALS
-	namespace literal
-	{
-		/// Half literal.
-		/// While this returns an actual half-precision value, half literals can unfortunately not be constant expressions due 
-		/// to rather involved conversions.
-		/// \param value literal value
-		/// \return half with given value (if representable)
-		inline half operator""_h(long double value) { return half(detail::binary, detail::float2half<half::round_style>(value)); }
-	}
+    namespace literal
+    {
+        /// Half literal.
+        /// While this returns an actual half-precision value, half literals can unfortunately not be constant expressions due 
+        /// to rather involved conversions.
+        /// \param value literal value
+        /// \return half with given value (if representable)
+        inline half operator""_h(long double value) { return half(detail::binary, detail::float2half<half::round_style>(value)); }
+    }
 #endif
 
-	namespace detail
-	{
-		/// Wrapper implementing unspecialized half-precision functions.
-		struct functions
-		{
-			/// Addition implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \return Half-precision sum stored in single-precision
-			static expr plus(float x, float y) { return expr(x+y); }
-
-			/// Subtraction implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \return Half-precision difference stored in single-precision
-			static expr minus(float x, float y) { return expr(x-y); }
-
-			/// Multiplication implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \return Half-precision product stored in single-precision
-			static expr multiplies(float x, float y) { return expr(x*y); }
-
-			/// Division implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \return Half-precision quotient stored in single-precision
-			static expr divides(float x, float y) { return expr(x/y); }
-
-			/// Output implementation.
-			/// \param out stream to write to
-			/// \param arg value to write
-			/// \return reference to stream
-			template<typename charT,typename traits> static std::basic_ostream<charT,traits>& write(std::basic_ostream<charT,traits> &out, float arg) { return out << arg; }
-
-			/// Input implementation.
-			/// \param in stream to read from
-			/// \param arg half to read into
-			/// \return reference to stream
-			template<typename charT,typename traits> static std::basic_istream<charT,traits>& read(std::basic_istream<charT,traits> &in, half &arg)
-			{
-				float f;
-				if(in >> f)
-					arg = f;
-				return in;
-			}
-
-			/// Modulo implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \return Half-precision division remainder stored in single-precision
-			static expr fmod(float x, float y) { return expr(std::fmod(x, y)); }
-
-			/// Remainder implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \return Half-precision division remainder stored in single-precision
-			static expr remainder(float x, float y)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::remainder(x, y));
-			#else
-				if(builtin_isnan(x) || builtin_isnan(y))
-					return expr(std::numeric_limits<float>::quiet_NaN());
-				float ax = std::fabs(x), ay = std::fabs(y);
-				if(ax >= 65536.0f || ay < std::ldexp(1.0f, -24))
-					return expr(std::numeric_limits<float>::quiet_NaN());
-				if(ay >= 65536.0f)
-					return expr(x);
-				if(ax == ay)
-					return expr(builtin_signbit(x) ? -0.0f : 0.0f);
-				ax = std::fmod(ax, ay+ay);
-				float y2 = 0.5f * ay;
-				if(ax > y2)
-				{
-					ax -= ay;
-					if(ax >= y2)
-						ax -= ay;
-				}
-				return expr(builtin_signbit(x) ? -ax : ax);
-			#endif
-			}
-
-			/// Remainder implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \param quo address to store quotient bits at
-			/// \return Half-precision division remainder stored in single-precision
-			static expr remquo(float x, float y, int *quo)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::remquo(x, y, quo));
-			#else
-				if(builtin_isnan(x) || builtin_isnan(y))
-					return expr(std::numeric_limits<float>::quiet_NaN());
-				bool sign = builtin_signbit(x), qsign = static_cast<bool>(sign^builtin_signbit(y));
-				float ax = std::fabs(x), ay = std::fabs(y);
-				if(ax >= 65536.0f || ay < std::ldexp(1.0f, -24))
-					return expr(std::numeric_limits<float>::quiet_NaN());
-				if(ay >= 65536.0f)
-					return expr(x);
-				if(ax == ay)
-					return *quo = qsign ? -1 : 1, expr(sign ? -0.0f : 0.0f);
-				ax = std::fmod(ax, 8.0f*ay);
-				int cquo = 0;
-				if(ax >= 4.0f * ay)
-				{
-					ax -= 4.0f * ay;
-					cquo += 4;
-				}
-				if(ax >= 2.0f * ay)
-				{
-					ax -= 2.0f * ay;
-					cquo += 2;
-				}
-				float y2 = 0.5f * ay;
-				if(ax > y2)
-				{
-					ax -= ay;
-					++cquo;
-					if(ax >= y2)
-					{
-						ax -= ay;
-						++cquo;
-					}
-				}
-				return *quo = qsign ? -cquo : cquo, expr(sign ? -ax : ax);
-			#endif
-			}
-
-			/// Positive difference implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \return Positive difference stored in single-precision
-			static expr fdim(float x, float y)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::fdim(x, y));
-			#else
-				return expr((x<=y) ? 0.0f : (x-y));
-			#endif
-			}
-
-			/// Fused multiply-add implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \param z third operand
-			/// \return \a x * \a y + \a z stored in single-precision
-			static expr fma(float x, float y, float z)
-			{
-			#if HALF_ENABLE_CPP11_CMATH && defined(FP_FAST_FMAF)
-				return expr(std::fma(x, y, z));
-			#else
-				return expr(x*y+z);
-			#endif
-			}
-
-			/// Get NaN.
-			/// \return Half-precision quiet NaN
-			static half nanh() { return half(binary, 0x7FFF); }
-
-			/// Exponential implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr exp(float arg) { return expr(std::exp(arg)); }
-
-			/// Exponential implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr expm1(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::expm1(arg));
-			#else
-				return expr(static_cast<float>(std::exp(static_cast<double>(arg))-1.0));
-			#endif
-			}
-
-			/// Binary exponential implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr exp2(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::exp2(arg));
-			#else
-				return expr(static_cast<float>(std::exp(arg*0.69314718055994530941723212145818)));
-			#endif
-			}
-
-			/// Logarithm implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr log(float arg) { return expr(std::log(arg)); }
-
-			/// Common logarithm implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr log10(float arg) { return expr(std::log10(arg)); }
-
-			/// Logarithm implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr log1p(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::log1p(arg));
-			#else
-				return expr(static_cast<float>(std::log(1.0+arg)));
-			#endif
-			}
-
-			/// Binary logarithm implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr log2(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::log2(arg));
-			#else
-				return expr(static_cast<float>(std::log(static_cast<double>(arg))*1.4426950408889634073599246810019));
-			#endif
-			}
-
-			/// Square root implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr sqrt(float arg) { return expr(std::sqrt(arg)); }
-
-			/// Cubic root implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr cbrt(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::cbrt(arg));
-			#else
-				if(builtin_isnan(arg) || builtin_isinf(arg))
-					return expr(arg);
-				return expr(builtin_signbit(arg) ? -static_cast<float>(std::pow(-static_cast<double>(arg), 1.0/3.0)) : 
-					static_cast<float>(std::pow(static_cast<double>(arg), 1.0/3.0)));
-			#endif
-			}
-
-			/// Hypotenuse implementation.
-			/// \param x first argument
-			/// \param y second argument
-			/// \return function value stored in single-preicision
-			static expr hypot(float x, float y)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::hypot(x, y));
-			#else
-				return expr((builtin_isinf(x) || builtin_isinf(y)) ? std::numeric_limits<float>::infinity() : 
-					static_cast<float>(std::sqrt(static_cast<double>(x)*x+static_cast<double>(y)*y)));
-			#endif
-			}
-
-			/// Power implementation.
-			/// \param base value to exponentiate
-			/// \param exp power to expontiate to
-			/// \return function value stored in single-preicision
-			static expr pow(float base, float exp) { return expr(std::pow(base, exp)); }
-
-			/// Sine implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr sin(float arg) { return expr(std::sin(arg)); }
-
-			/// Cosine implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr cos(float arg) { return expr(std::cos(arg)); }
-
-			/// Tan implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr tan(float arg) { return expr(std::tan(arg)); }
-
-			/// Arc sine implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr asin(float arg) { return expr(std::asin(arg)); }
-
-			/// Arc cosine implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr acos(float arg) { return expr(std::acos(arg)); }
-
-			/// Arc tangent implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr atan(float arg) { return expr(std::atan(arg)); }
-
-			/// Arc tangent implementation.
-			/// \param x first argument
-			/// \param y second argument
-			/// \return function value stored in single-preicision
-			static expr atan2(float x, float y) { return expr(std::atan2(x, y)); }
-
-			/// Hyperbolic sine implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr sinh(float arg) { return expr(std::sinh(arg)); }
-
-			/// Hyperbolic cosine implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr cosh(float arg) { return expr(std::cosh(arg)); }
-
-			/// Hyperbolic tangent implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr tanh(float arg) { return expr(std::tanh(arg)); }
-
-			/// Hyperbolic area sine implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr asinh(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::asinh(arg));
-			#else
-				return expr((arg==-std::numeric_limits<float>::infinity()) ? arg : static_cast<float>(std::log(arg+std::sqrt(arg*arg+1.0))));
-			#endif
-			}
-
-			/// Hyperbolic area cosine implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr acosh(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::acosh(arg));
-			#else
-				return expr((arg<-1.0f) ? std::numeric_limits<float>::quiet_NaN() : static_cast<float>(std::log(arg+std::sqrt(arg*arg-1.0))));
-			#endif
-			}
-
-			/// Hyperbolic area tangent implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr atanh(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::atanh(arg));
-			#else
-				return expr(static_cast<float>(0.5*std::log((1.0+arg)/(1.0-arg))));
-			#endif
-			}
-
-			/// Error function implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr erf(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::erf(arg));
-			#else
-				return expr(static_cast<float>(erf(static_cast<double>(arg))));
-			#endif
-			}
-
-			/// Complementary implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr erfc(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::erfc(arg));
-			#else
-				return expr(static_cast<float>(1.0-erf(static_cast<double>(arg))));
-			#endif
-			}
-
-			/// Gamma logarithm implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr lgamma(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::lgamma(arg));
-			#else
-				if(builtin_isinf(arg))
-					return expr(std::numeric_limits<float>::infinity());
-				if(arg < 0.0f)
-				{
-					float i, f = std::modf(-arg, &i);
-					if(f == 0.0f)
-						return expr(std::numeric_limits<float>::infinity());
-					return expr(static_cast<float>(1.1447298858494001741434273513531-
-						std::log(std::abs(std::sin(3.1415926535897932384626433832795*f)))-lgamma(1.0-arg)));
-				}
-				return expr(static_cast<float>(lgamma(static_cast<double>(arg))));
-			#endif
-			}
-
-			/// Gamma implementation.
-			/// \param arg function argument
-			/// \return function value stored in single-preicision
-			static expr tgamma(float arg)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::tgamma(arg));
-			#else
-				if(arg == 0.0f)
-					return builtin_signbit(arg) ? expr(-std::numeric_limits<float>::infinity()) : expr(std::numeric_limits<float>::infinity());
-				if(arg < 0.0f)
-				{
-					float i, f = std::modf(-arg, &i);
-					if(f == 0.0f)
-						return expr(std::numeric_limits<float>::quiet_NaN());
-					double value = 3.1415926535897932384626433832795 / (std::sin(3.1415926535897932384626433832795*f)*std::exp(lgamma(1.0-arg)));
-					return expr(static_cast<float>((std::fmod(i, 2.0f)==0.0f) ? -value : value));
-				}
-				if(builtin_isinf(arg))
-					return expr(arg);
-				return expr(static_cast<float>(std::exp(lgamma(static_cast<double>(arg)))));
-			#endif
-			}
-
-			/// Floor implementation.
-			/// \param arg value to round
-			/// \return rounded value
-			static half floor(half arg) { return half(binary, round_half<std::round_toward_neg_infinity>(arg.data_)); }
-
-			/// Ceiling implementation.
-			/// \param arg value to round
-			/// \return rounded value
-			static half ceil(half arg) { return half(binary, round_half<std::round_toward_infinity>(arg.data_)); }
-
-			/// Truncation implementation.
-			/// \param arg value to round
-			/// \return rounded value
-			static half trunc(half arg) { return half(binary, round_half<std::round_toward_zero>(arg.data_)); }
-
-			/// Nearest integer implementation.
-			/// \param arg value to round
-			/// \return rounded value
-			static half round(half arg) { return half(binary, round_half_up(arg.data_)); }
-
-			/// Nearest integer implementation.
-			/// \param arg value to round
-			/// \return rounded value
-			static long lround(half arg) { return detail::half2int_up<long>(arg.data_); }
-
-			/// Nearest integer implementation.
-			/// \param arg value to round
-			/// \return rounded value
-			static half rint(half arg) { return half(binary, round_half<half::round_style>(arg.data_)); }
-
-			/// Nearest integer implementation.
-			/// \param arg value to round
-			/// \return rounded value
-			static long lrint(half arg) { return detail::half2int<half::round_style,long>(arg.data_); }
-
-		#if HALF_ENABLE_CPP11_LONG_LONG
-			/// Nearest integer implementation.
-			/// \param arg value to round
-			/// \return rounded value
-			static long long llround(half arg) { return detail::half2int_up<long long>(arg.data_); }
-
-			/// Nearest integer implementation.
-			/// \param arg value to round
-			/// \return rounded value
-			static long long llrint(half arg) { return detail::half2int<half::round_style,long long>(arg.data_); }
-		#endif
-
-			/// Decompression implementation.
-			/// \param arg number to decompress
-			/// \param exp address to store exponent at
-			/// \return normalized significant
-			static half frexp(half arg, int *exp)
-			{
-				int m = arg.data_ & 0x7FFF, e = -14;
-				if(m >= 0x7C00 || !m)
-					return *exp = 0, arg;
-				for(; m<0x400; m<<=1,--e) ;
-				return *exp = e+(m>>10), half(binary, (arg.data_&0x8000)|0x3800|(m&0x3FF));
-			}
-
-			/// Decompression implementation.
-			/// \param arg number to decompress
-			/// \param iptr address to store integer part at
-			/// \return fractional part
-			static half modf(half arg, half *iptr)
-			{
-				unsigned int e = arg.data_ & 0x7FFF;
-				if(e >= 0x6400)
-					return *iptr = arg, half(binary, arg.data_&(0x8000U|-(e>0x7C00)));
-				if(e < 0x3C00)
-					return iptr->data_ = arg.data_ & 0x8000, arg;
-				e >>= 10;
-				unsigned int mask = (1<<(25-e)) - 1, m = arg.data_ & mask;
-				iptr->data_ = arg.data_ & ~mask;
-				if(!m)
-					return half(binary, arg.data_&0x8000);
-				for(; m<0x400; m<<=1,--e) ;
-				return half(binary, static_cast<uint16>((arg.data_&0x8000)|(e<<10)|(m&0x3FF)));
-			}
-
-			/// Scaling implementation.
-			/// \param arg number to scale
-			/// \param exp power of two to scale by
-			/// \return scaled number
-			static half scalbln(half arg, long exp)
-			{
-				unsigned int m = arg.data_ & 0x7FFF;
-				if(m >= 0x7C00 || !m)
-					return arg;
-				for(; m<0x400; m<<=1,--exp) ;
-				exp += m >> 10;
-				uint16 value = arg.data_ & 0x8000;
-				if(exp > 30)
-				{
-					if(half::round_style == std::round_toward_zero)
-						value |= 0x7BFF;
-					else if(half::round_style == std::round_toward_infinity)
-						value |= 0x7C00 - (value>>15);
-					else if(half::round_style == std::round_toward_neg_infinity)
-						value |= 0x7BFF + (value>>15);
-					else
-						value |= 0x7C00;
-				}
-				else if(exp > 0)
-					value |= (exp<<10) | (m&0x3FF);
-				else if(exp > -11)
-				{
-					m = (m&0x3FF) | 0x400;
-					if(half::round_style == std::round_to_nearest)
-					{
-						m += 1 << -exp;
-					#if HALF_ROUND_TIES_TO_EVEN
-						m -= (m>>(1-exp)) & 1;
-					#endif
-					}
-					else if(half::round_style == std::round_toward_infinity)
-						m += ((value>>15)-1) & ((1<<(1-exp))-1U);
-					else if(half::round_style == std::round_toward_neg_infinity)
-						m += -(value>>15) & ((1<<(1-exp))-1U);
-					value |= m >> (1-exp);
-				}
-				else if(half::round_style == std::round_toward_infinity)
-					value -= (value>>15) - 1;
-				else if(half::round_style == std::round_toward_neg_infinity)
-					value += value >> 15;
-				return half(binary, value);
-			}
-
-			/// Exponent implementation.
-			/// \param arg number to query
-			/// \return floating point exponent
-			static int ilogb(half arg)
-			{
-				int abs = arg.data_ & 0x7FFF;
-				if(!abs)
-					return FP_ILOGB0;
-				if(abs < 0x7C00)
-				{
-					int exp = (abs>>10) - 15;
-					if(abs < 0x400)
-						for(; abs<0x200; abs<<=1,--exp) ;
-					return exp;
-				}
-				if(abs > 0x7C00)
-					return FP_ILOGBNAN;
-				return INT_MAX;
-			}
-
-			/// Exponent implementation.
-			/// \param arg number to query
-			/// \return floating point exponent
-			static half logb(half arg)
-			{
-				int abs = arg.data_ & 0x7FFF;
-				if(!abs)
-					return half(binary, 0xFC00);
-				if(abs < 0x7C00)
-				{
-					int exp = (abs>>10) - 15;
-					if(abs < 0x400)
-						for(; abs<0x200; abs<<=1,--exp) ;
-					uint16 bits = (exp<0) << 15;
-					if(exp)
-					{
-						unsigned int m = std::abs(exp) << 6, e = 18;
-						for(; m<0x400; m<<=1,--e) ;
-						bits |= (e<<10) + m;
-					}
-					return half(binary, bits);
-				}
-				if(abs > 0x7C00)
-					return arg;
-				return half(binary, 0x7C00);
-			}
-
-			/// Enumeration implementation.
-			/// \param from number to increase/decrease
-			/// \param to direction to enumerate into
-			/// \return next representable number
-			static half nextafter(half from, half to)
-			{
-				uint16 fabs = from.data_ & 0x7FFF, tabs = to.data_ & 0x7FFF;
-				if(fabs > 0x7C00)
-					return from;
-				if(tabs > 0x7C00 || from.data_ == to.data_ || !(fabs|tabs))
-					return to;
-				if(!fabs)
-					return half(binary, (to.data_&0x8000)+1);
-				bool lt = ((fabs==from.data_) ? static_cast<int>(fabs) : -static_cast<int>(fabs)) < 
-					((tabs==to.data_) ? static_cast<int>(tabs) : -static_cast<int>(tabs));
-				return half(binary, from.data_+(((from.data_>>15)^static_cast<unsigned>(lt))<<1)-1);
-			}
-
-			/// Enumeration implementation.
-			/// \param from number to increase/decrease
-			/// \param to direction to enumerate into
-			/// \return next representable number
-			static half nexttoward(half from, long double to)
-			{
-				if(isnan(from))
-					return from;
-				long double lfrom = static_cast<long double>(from);
-				if(builtin_isnan(to) || lfrom == to)
-					return half(static_cast<float>(to));
-				if(!(from.data_&0x7FFF))
-					return half(binary, (static_cast<detail::uint16>(builtin_signbit(to))<<15)+1);
-				return half(binary, from.data_+(((from.data_>>15)^static_cast<unsigned>(lfrom<to))<<1)-1);
-			}
-
-			/// Sign implementation
-			/// \param x first operand
-			/// \param y second operand
-			/// \return composed value
-			static half copysign(half x, half y) { return half(binary, x.data_^((x.data_^y.data_)&0x8000)); }
-
-			/// Classification implementation.
-			/// \param arg value to classify
-			/// \retval true if infinite number
-			/// \retval false else
-			static int fpclassify(half arg)
-			{
-				unsigned int abs = arg.data_ & 0x7FFF;
-				return abs ? ((abs>0x3FF) ? ((abs>=0x7C00) ? ((abs>0x7C00) ? FP_NAN : FP_INFINITE) : FP_NORMAL) :FP_SUBNORMAL) : FP_ZERO;
-			}
-
-			/// Classification implementation.
-			/// \param arg value to classify
-			/// \retval true if finite number
-			/// \retval false else
-			static bool isfinite(half arg) { return (arg.data_&0x7C00) != 0x7C00; }
-
-			/// Classification implementation.
-			/// \param arg value to classify
-			/// \retval true if infinite number
-			/// \retval false else
-			static bool isinf(half arg) { return (arg.data_&0x7FFF) == 0x7C00; }
-
-			/// Classification implementation.
-			/// \param arg value to classify
-			/// \retval true if not a number
-			/// \retval false else
-			static bool isnan(half arg) { return (arg.data_&0x7FFF) > 0x7C00; }
-
-			/// Classification implementation.
-			/// \param arg value to classify
-			/// \retval true if normal number
-			/// \retval false else
-			static bool isnormal(half arg) { return ((arg.data_&0x7C00)!=0) & ((arg.data_&0x7C00)!=0x7C00); }
-
-			/// Sign bit implementation.
-			/// \param arg value to check
-			/// \retval true if signed
-			/// \retval false if unsigned
-			static bool signbit(half arg) { return (arg.data_&0x8000) != 0; }
-
-			/// Comparison implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \retval true if operands equal
-			/// \retval false else
-			static bool isequal(half x, half y) { return (x.data_==y.data_ || !((x.data_|y.data_)&0x7FFF)) && !isnan(x); }
-
-			/// Comparison implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \retval true if operands not equal
-			/// \retval false else
-			static bool isnotequal(half x, half y) { return (x.data_!=y.data_ && ((x.data_|y.data_)&0x7FFF)) || isnan(x); }
-
-			/// Comparison implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \retval true if \a x > \a y
-			/// \retval false else
-			static bool isgreater(half x, half y)
-			{
-				int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
-				return xabs<=0x7C00 && yabs<=0x7C00 && (((xabs==x.data_) ? xabs : -xabs) > ((yabs==y.data_) ? yabs : -yabs));
-			}
-
-			/// Comparison implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \retval true if \a x >= \a y
-			/// \retval false else
-			static bool isgreaterequal(half x, half y)
-			{
-				int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
-				return xabs<=0x7C00 && yabs<=0x7C00 && (((xabs==x.data_) ? xabs : -xabs) >= ((yabs==y.data_) ? yabs : -yabs));
-			}
-
-			/// Comparison implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \retval true if \a x < \a y
-			/// \retval false else
-			static bool isless(half x, half y)
-			{
-				int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
-				return xabs<=0x7C00 && yabs<=0x7C00 && (((xabs==x.data_) ? xabs : -xabs) < ((yabs==y.data_) ? yabs : -yabs));
-			}
-
-			/// Comparison implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \retval true if \a x <= \a y
-			/// \retval false else
-			static bool islessequal(half x, half y)
-			{
-				int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
-				return xabs<=0x7C00 && yabs<=0x7C00 && (((xabs==x.data_) ? xabs : -xabs) <= ((yabs==y.data_) ? yabs : -yabs));
-			}
-
-			/// Comparison implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \retval true if either \a x > \a y nor \a x < \a y
-			/// \retval false else
-			static bool islessgreater(half x, half y)
-			{
-				int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
-				if(xabs > 0x7C00 || yabs > 0x7C00)
-					return false;
-				int a = (xabs==x.data_) ? xabs : -xabs, b = (yabs==y.data_) ? yabs : -yabs;
-				return a < b || a > b;
-			}
-
-			/// Comparison implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \retval true if operand unordered
-			/// \retval false else
-			static bool isunordered(half x, half y) { return isnan(x) || isnan(y); }
-
-		private:
-			static double erf(double arg)
-			{
-				if(builtin_isinf(arg))
-					return (arg<0.0) ? -1.0 : 1.0;
-				double x2 = arg * arg, ax2 = 0.147 * x2, value = std::sqrt(1.0-std::exp(-x2*(1.2732395447351626861510701069801+ax2)/(1.0+ax2)));
-				return builtin_signbit(arg) ? -value : value;
-			}
-
-			static double lgamma(double arg)
-			{
-				double v = 1.0;
-				for(; arg<8.0; ++arg) v *= arg;
-				double w = 1.0 / (arg*arg);
-				return (((((((-0.02955065359477124183006535947712*w+0.00641025641025641025641025641026)*w+
-					-0.00191752691752691752691752691753)*w+8.4175084175084175084175084175084e-4)*w+
-					-5.952380952380952380952380952381e-4)*w+7.9365079365079365079365079365079e-4)*w+
-					-0.00277777777777777777777777777778)*w+0.08333333333333333333333333333333)/arg + 
-					0.91893853320467274178032973640562 - std::log(v) - arg + (arg-0.5) * std::log(arg);
-			}
-		};
-
-		/// Wrapper for unary half-precision functions needing specialization for individual argument types.
-		/// \tparam T argument type
-		template<typename T> struct unary_specialized
-		{
-			/// Negation implementation.
-			/// \param arg value to negate
-			/// \return negated value
-			static HALF_CONSTEXPR half negate(half arg) { return half(binary, arg.data_^0x8000); }
-
-			/// Absolute value implementation.
-			/// \param arg function argument
-			/// \return absolute value
-			static half fabs(half arg) { return half(binary, arg.data_&0x7FFF); }
-		};
-		template<> struct unary_specialized<expr>
-		{
-			static HALF_CONSTEXPR expr negate(float arg) { return expr(-arg); }
-			static expr fabs(float arg) { return expr(std::fabs(arg)); }
-		};
-
-		/// Wrapper for binary half-precision functions needing specialization for individual argument types.
-		/// \tparam T first argument type
-		/// \tparam U first argument type
-		template<typename T,typename U> struct binary_specialized
-		{
-			/// Minimum implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \return minimum value
-			static expr fmin(float x, float y)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::fmin(x, y));
-			#else
-				if(builtin_isnan(x))
-					return expr(y);
-				if(builtin_isnan(y))
-					return expr(x);
-				return expr(std::min(x, y));
-			#endif
-			}
-
-			/// Maximum implementation.
-			/// \param x first operand
-			/// \param y second operand
-			/// \return maximum value
-			static expr fmax(float x, float y)
-			{
-			#if HALF_ENABLE_CPP11_CMATH
-				return expr(std::fmax(x, y));
-			#else
-				if(builtin_isnan(x))
-					return expr(y);
-				if(builtin_isnan(y))
-					return expr(x);
-				return expr(std::max(x, y));
-			#endif
-			}
-		};
-		template<> struct binary_specialized<half,half>
-		{
-			static half fmin(half x, half y)
-			{
-				int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
-				if(xabs > 0x7C00)
-					return y;
-				if(yabs > 0x7C00)
-					return x;
-				return (((xabs==x.data_) ? xabs : -xabs) > ((yabs==y.data_) ? yabs : -yabs)) ? y : x;
-			}
-			static half fmax(half x, half y)
-			{
-				int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
-				if(xabs > 0x7C00)
-					return y;
-				if(yabs > 0x7C00)
-					return x;
-				return (((xabs==x.data_) ? xabs : -xabs) < ((yabs==y.data_) ? yabs : -yabs)) ? y : x;
-			}
-		};
-
-		/// Helper class for half casts.
-		/// This class template has to be specialized for all valid cast argument to define an appropriate static `cast` member 
-		/// function and a corresponding `type` member denoting its return type.
-		/// \tparam T destination type
-		/// \tparam U source type
-		/// \tparam R rounding mode to use
-		template<typename T,typename U,std::float_round_style R=(std::float_round_style)(HALF_ROUND_STYLE)> struct half_caster {};
-		template<typename U,std::float_round_style R> struct half_caster<half,U,R>
-		{
-		#if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
-			static_assert(std::is_arithmetic<U>::value, "half_cast from non-arithmetic type unsupported");
-		#endif
-
-			static half cast(U arg) { return cast_impl(arg, is_float<U>()); };
-
-		private:
-			static half cast_impl(U arg, true_type) { return half(binary, float2half<R>(arg)); }
-			static half cast_impl(U arg, false_type) { return half(binary, int2half<R>(arg)); }
-		};
-		template<typename T,std::float_round_style R> struct half_caster<T,half,R>
-		{
-		#if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
-			static_assert(std::is_arithmetic<T>::value, "half_cast to non-arithmetic type unsupported");
-		#endif
-
-			static T cast(half arg) { return cast_impl(arg, is_float<T>()); }
-
-		private:
-			static T cast_impl(half arg, true_type) { return half2float<T>(arg.data_); }
-			static T cast_impl(half arg, false_type) { return half2int<R,T>(arg.data_); }
-		};
-		template<typename T,std::float_round_style R> struct half_caster<T,expr,R>
-		{
-		#if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
-			static_assert(std::is_arithmetic<T>::value, "half_cast to non-arithmetic type unsupported");
-		#endif
-
-			static T cast(expr arg) { return cast_impl(arg, is_float<T>()); }
-
-		private:
-			static T cast_impl(float arg, true_type) { return static_cast<T>(arg); }
-			static T cast_impl(half arg, false_type) { return half2int<R,T>(arg.data_); }
-		};
-		template<std::float_round_style R> struct half_caster<half,half,R>
-		{
-			static half cast(half arg) { return arg; }
-		};
-		template<std::float_round_style R> struct half_caster<half,expr,R> : half_caster<half,half,R> {};
-
-		/// \name Comparison operators
-		/// \{
-
-		/// Comparison for equality.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if operands equal
-		/// \retval false else
-		template<typename T,typename U> typename enable<bool,T,U>::type operator==(T x, U y) { return functions::isequal(x, y); }
-
-		/// Comparison for inequality.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if operands not equal
-		/// \retval false else
-		template<typename T,typename U> typename enable<bool,T,U>::type operator!=(T x, U y) { return functions::isnotequal(x, y); }
-
-		/// Comparison for less than.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if \a x less than \a y
-		/// \retval false else
-		template<typename T,typename U> typename enable<bool,T,U>::type operator<(T x, U y) { return functions::isless(x, y); }
-
-		/// Comparison for greater than.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if \a x greater than \a y
-		/// \retval false else
-		template<typename T,typename U> typename enable<bool,T,U>::type operator>(T x, U y) { return functions::isgreater(x, y); }
-
-		/// Comparison for less equal.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if \a x less equal \a y
-		/// \retval false else
-		template<typename T,typename U> typename enable<bool,T,U>::type operator<=(T x, U y) { return functions::islessequal(x, y); }
-
-		/// Comparison for greater equal.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if \a x greater equal \a y
-		/// \retval false else
-		template<typename T,typename U> typename enable<bool,T,U>::type operator>=(T x, U y) { return functions::isgreaterequal(x, y); }
-
-		/// \}
-		/// \name Arithmetic operators
-		/// \{
-
-		/// Add halfs.
-		/// \param x left operand
-		/// \param y right operand
-		/// \return sum of half expressions
-		template<typename T,typename U> typename enable<expr,T,U>::type operator+(T x, U y) { return functions::plus(x, y); }
-
-		/// Subtract halfs.
-		/// \param x left operand
-		/// \param y right operand
-		/// \return difference of half expressions
-		template<typename T,typename U> typename enable<expr,T,U>::type operator-(T x, U y) { return functions::minus(x, y); }
-
-		/// Multiply halfs.
-		/// \param x left operand
-		/// \param y right operand
-		/// \return product of half expressions
-		template<typename T,typename U> typename enable<expr,T,U>::type operator*(T x, U y) { return functions::multiplies(x, y); }
-
-		/// Divide halfs.
-		/// \param x left operand
-		/// \param y right operand
-		/// \return quotient of half expressions
-		template<typename T,typename U> typename enable<expr,T,U>::type operator/(T x, U y) { return functions::divides(x, y); }
-
-		/// Identity.
-		/// \param arg operand
-		/// \return uncahnged operand
-		template<typename T> HALF_CONSTEXPR typename enable<T,T>::type operator+(T arg) { return arg; }
-
-		/// Negation.
-		/// \param arg operand
-		/// \return negated operand
-		template<typename T> HALF_CONSTEXPR typename enable<T,T>::type operator-(T arg) { return unary_specialized<T>::negate(arg); }
-
-		/// \}
-		/// \name Input and output
-		/// \{
-
-		/// Output operator.
-		/// \param out output stream to write into
-		/// \param arg half expression to write
-		/// \return reference to output stream
-		template<typename T,typename charT,typename traits> typename enable<std::basic_ostream<charT,traits>&,T>::type
-			operator<<(std::basic_ostream<charT,traits> &out, T arg) { return functions::write(out, arg); }
-
-		/// Input operator.
-		/// \param in input stream to read from
-		/// \param arg half to read into
-		/// \return reference to input stream
-		template<typename charT,typename traits> std::basic_istream<charT,traits>&
-			operator>>(std::basic_istream<charT,traits> &in, half &arg) { return functions::read(in, arg); }
-
-		/// \}
-		/// \name Basic mathematical operations
-		/// \{
-
-		/// Absolute value.
-		/// \param arg operand
-		/// \return absolute value of \a arg
+    namespace detail
+    {
+        /// Wrapper implementing unspecialized half-precision functions.
+        struct functions
+        {
+            /// Addition implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \return Half-precision sum stored in single-precision
+            static expr plus(float x, float y) { return expr(x+y); }
+
+            /// Subtraction implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \return Half-precision difference stored in single-precision
+            static expr minus(float x, float y) { return expr(x-y); }
+
+            /// Multiplication implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \return Half-precision product stored in single-precision
+            static expr multiplies(float x, float y) { return expr(x*y); }
+
+            /// Division implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \return Half-precision quotient stored in single-precision
+            static expr divides(float x, float y) { return expr(x/y); }
+
+            /// Output implementation.
+            /// \param out stream to write to
+            /// \param arg value to write
+            /// \return reference to stream
+            template<typename charT,typename traits> static std::basic_ostream<charT,traits>& write(std::basic_ostream<charT,traits> &out, float arg) { return out << arg; }
+
+            /// Input implementation.
+            /// \param in stream to read from
+            /// \param arg half to read into
+            /// \return reference to stream
+            template<typename charT,typename traits> static std::basic_istream<charT,traits>& read(std::basic_istream<charT,traits> &in, half &arg)
+            {
+                float f;
+                if(in >> f)
+                    arg = f;
+                return in;
+            }
+
+            /// Modulo implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \return Half-precision division remainder stored in single-precision
+            static expr fmod(float x, float y) { return expr(std::fmod(x, y)); }
+
+            /// Remainder implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \return Half-precision division remainder stored in single-precision
+            static expr remainder(float x, float y)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::remainder(x, y));
+            #else
+                if(builtin_isnan(x) || builtin_isnan(y))
+                    return expr(std::numeric_limits<float>::quiet_NaN());
+                float ax = std::fabs(x), ay = std::fabs(y);
+                if(ax >= 65536.0f || ay < std::ldexp(1.0f, -24))
+                    return expr(std::numeric_limits<float>::quiet_NaN());
+                if(ay >= 65536.0f)
+                    return expr(x);
+                if(ax == ay)
+                    return expr(builtin_signbit(x) ? -0.0f : 0.0f);
+                ax = std::fmod(ax, ay+ay);
+                float y2 = 0.5f * ay;
+                if(ax > y2)
+                {
+                    ax -= ay;
+                    if(ax >= y2)
+                        ax -= ay;
+                }
+                return expr(builtin_signbit(x) ? -ax : ax);
+            #endif
+            }
+
+            /// Remainder implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \param quo address to store quotient bits at
+            /// \return Half-precision division remainder stored in single-precision
+            static expr remquo(float x, float y, int *quo)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::remquo(x, y, quo));
+            #else
+                if(builtin_isnan(x) || builtin_isnan(y))
+                    return expr(std::numeric_limits<float>::quiet_NaN());
+                bool sign = builtin_signbit(x), qsign = static_cast<bool>(sign^builtin_signbit(y));
+                float ax = std::fabs(x), ay = std::fabs(y);
+                if(ax >= 65536.0f || ay < std::ldexp(1.0f, -24))
+                    return expr(std::numeric_limits<float>::quiet_NaN());
+                if(ay >= 65536.0f)
+                    return expr(x);
+                if(ax == ay)
+                    return *quo = qsign ? -1 : 1, expr(sign ? -0.0f : 0.0f);
+                ax = std::fmod(ax, 8.0f*ay);
+                int cquo = 0;
+                if(ax >= 4.0f * ay)
+                {
+                    ax -= 4.0f * ay;
+                    cquo += 4;
+                }
+                if(ax >= 2.0f * ay)
+                {
+                    ax -= 2.0f * ay;
+                    cquo += 2;
+                }
+                float y2 = 0.5f * ay;
+                if(ax > y2)
+                {
+                    ax -= ay;
+                    ++cquo;
+                    if(ax >= y2)
+                    {
+                        ax -= ay;
+                        ++cquo;
+                    }
+                }
+                return *quo = qsign ? -cquo : cquo, expr(sign ? -ax : ax);
+            #endif
+            }
+
+            /// Positive difference implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \return Positive difference stored in single-precision
+            static expr fdim(float x, float y)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::fdim(x, y));
+            #else
+                return expr((x<=y) ? 0.0f : (x-y));
+            #endif
+            }
+
+            /// Fused multiply-add implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \param z third operand
+            /// \return \a x * \a y + \a z stored in single-precision
+            static expr fma(float x, float y, float z)
+            {
+            #if HALF_ENABLE_CPP11_CMATH && defined(FP_FAST_FMAF)
+                return expr(std::fma(x, y, z));
+            #else
+                return expr(x*y+z);
+            #endif
+            }
+
+            /// Get NaN.
+            /// \return Half-precision quiet NaN
+            static half nanh() { return half(binary, 0x7FFF); }
+
+            /// Exponential implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr exp(float arg) { return expr(std::exp(arg)); }
+
+            /// Exponential implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr expm1(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::expm1(arg));
+            #else
+                return expr(static_cast<float>(std::exp(static_cast<double>(arg))-1.0));
+            #endif
+            }
+
+            /// Binary exponential implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr exp2(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::exp2(arg));
+            #else
+                return expr(static_cast<float>(std::exp(arg*0.69314718055994530941723212145818)));
+            #endif
+            }
+
+            /// Logarithm implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr log(float arg) { return expr(std::log(arg)); }
+
+            /// Common logarithm implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr log10(float arg) { return expr(std::log10(arg)); }
+
+            /// Logarithm implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr log1p(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::log1p(arg));
+            #else
+                return expr(static_cast<float>(std::log(1.0+arg)));
+            #endif
+            }
+
+            /// Binary logarithm implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr log2(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::log2(arg));
+            #else
+                return expr(static_cast<float>(std::log(static_cast<double>(arg))*1.4426950408889634073599246810019));
+            #endif
+            }
+
+            /// Square root implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr sqrt(float arg) { return expr(std::sqrt(arg)); }
+
+            /// Cubic root implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr cbrt(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::cbrt(arg));
+            #else
+                if(builtin_isnan(arg) || builtin_isinf(arg))
+                    return expr(arg);
+                return expr(builtin_signbit(arg) ? -static_cast<float>(std::pow(-static_cast<double>(arg), 1.0/3.0)) : 
+                    static_cast<float>(std::pow(static_cast<double>(arg), 1.0/3.0)));
+            #endif
+            }
+
+            /// Hypotenuse implementation.
+            /// \param x first argument
+            /// \param y second argument
+            /// \return function value stored in single-preicision
+            static expr hypot(float x, float y)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::hypot(x, y));
+            #else
+                return expr((builtin_isinf(x) || builtin_isinf(y)) ? std::numeric_limits<float>::infinity() : 
+                    static_cast<float>(std::sqrt(static_cast<double>(x)*x+static_cast<double>(y)*y)));
+            #endif
+            }
+
+            /// Power implementation.
+            /// \param base value to exponentiate
+            /// \param exp power to expontiate to
+            /// \return function value stored in single-preicision
+            static expr pow(float base, float exp) { return expr(std::pow(base, exp)); }
+
+            /// Sine implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr sin(float arg) { return expr(std::sin(arg)); }
+
+            /// Cosine implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr cos(float arg) { return expr(std::cos(arg)); }
+
+            /// Tan implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr tan(float arg) { return expr(std::tan(arg)); }
+
+            /// Arc sine implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr asin(float arg) { return expr(std::asin(arg)); }
+
+            /// Arc cosine implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr acos(float arg) { return expr(std::acos(arg)); }
+
+            /// Arc tangent implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr atan(float arg) { return expr(std::atan(arg)); }
+
+            /// Arc tangent implementation.
+            /// \param x first argument
+            /// \param y second argument
+            /// \return function value stored in single-preicision
+            static expr atan2(float x, float y) { return expr(std::atan2(x, y)); }
+
+            /// Hyperbolic sine implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr sinh(float arg) { return expr(std::sinh(arg)); }
+
+            /// Hyperbolic cosine implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr cosh(float arg) { return expr(std::cosh(arg)); }
+
+            /// Hyperbolic tangent implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr tanh(float arg) { return expr(std::tanh(arg)); }
+
+            /// Hyperbolic area sine implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr asinh(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::asinh(arg));
+            #else
+                return expr((arg==-std::numeric_limits<float>::infinity()) ? arg : static_cast<float>(std::log(arg+std::sqrt(arg*arg+1.0))));
+            #endif
+            }
+
+            /// Hyperbolic area cosine implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr acosh(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::acosh(arg));
+            #else
+                return expr((arg<-1.0f) ? std::numeric_limits<float>::quiet_NaN() : static_cast<float>(std::log(arg+std::sqrt(arg*arg-1.0))));
+            #endif
+            }
+
+            /// Hyperbolic area tangent implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr atanh(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::atanh(arg));
+            #else
+                return expr(static_cast<float>(0.5*std::log((1.0+arg)/(1.0-arg))));
+            #endif
+            }
+
+            /// Error function implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr erf(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::erf(arg));
+            #else
+                return expr(static_cast<float>(erf(static_cast<double>(arg))));
+            #endif
+            }
+
+            /// Complementary implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr erfc(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::erfc(arg));
+            #else
+                return expr(static_cast<float>(1.0-erf(static_cast<double>(arg))));
+            #endif
+            }
+
+            /// Gamma logarithm implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr lgamma(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::lgamma(arg));
+            #else
+                if(builtin_isinf(arg))
+                    return expr(std::numeric_limits<float>::infinity());
+                if(arg < 0.0f)
+                {
+                    float i, f = std::modf(-arg, &i);
+                    if(f == 0.0f)
+                        return expr(std::numeric_limits<float>::infinity());
+                    return expr(static_cast<float>(1.1447298858494001741434273513531-
+                        std::log(std::abs(std::sin(3.1415926535897932384626433832795*f)))-lgamma(1.0-arg)));
+                }
+                return expr(static_cast<float>(lgamma(static_cast<double>(arg))));
+            #endif
+            }
+
+            /// Gamma implementation.
+            /// \param arg function argument
+            /// \return function value stored in single-preicision
+            static expr tgamma(float arg)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::tgamma(arg));
+            #else
+                if(arg == 0.0f)
+                    return builtin_signbit(arg) ? expr(-std::numeric_limits<float>::infinity()) : expr(std::numeric_limits<float>::infinity());
+                if(arg < 0.0f)
+                {
+                    float i, f = std::modf(-arg, &i);
+                    if(f == 0.0f)
+                        return expr(std::numeric_limits<float>::quiet_NaN());
+                    double value = 3.1415926535897932384626433832795 / (std::sin(3.1415926535897932384626433832795*f)*std::exp(lgamma(1.0-arg)));
+                    return expr(static_cast<float>((std::fmod(i, 2.0f)==0.0f) ? -value : value));
+                }
+                if(builtin_isinf(arg))
+                    return expr(arg);
+                return expr(static_cast<float>(std::exp(lgamma(static_cast<double>(arg)))));
+            #endif
+            }
+
+            /// Floor implementation.
+            /// \param arg value to round
+            /// \return rounded value
+            static half floor(half arg) { return half(binary, round_half<std::round_toward_neg_infinity>(arg.data_)); }
+
+            /// Ceiling implementation.
+            /// \param arg value to round
+            /// \return rounded value
+            static half ceil(half arg) { return half(binary, round_half<std::round_toward_infinity>(arg.data_)); }
+
+            /// Truncation implementation.
+            /// \param arg value to round
+            /// \return rounded value
+            static half trunc(half arg) { return half(binary, round_half<std::round_toward_zero>(arg.data_)); }
+
+            /// Nearest integer implementation.
+            /// \param arg value to round
+            /// \return rounded value
+            static half round(half arg) { return half(binary, round_half_up(arg.data_)); }
+
+            /// Nearest integer implementation.
+            /// \param arg value to round
+            /// \return rounded value
+            static long lround(half arg) { return detail::half2int_up<long>(arg.data_); }
+
+            /// Nearest integer implementation.
+            /// \param arg value to round
+            /// \return rounded value
+            static half rint(half arg) { return half(binary, round_half<half::round_style>(arg.data_)); }
+
+            /// Nearest integer implementation.
+            /// \param arg value to round
+            /// \return rounded value
+            static long lrint(half arg) { return detail::half2int<half::round_style,long>(arg.data_); }
+
+        #if HALF_ENABLE_CPP11_LONG_LONG
+            /// Nearest integer implementation.
+            /// \param arg value to round
+            /// \return rounded value
+            static long long llround(half arg) { return detail::half2int_up<long long>(arg.data_); }
+
+            /// Nearest integer implementation.
+            /// \param arg value to round
+            /// \return rounded value
+            static long long llrint(half arg) { return detail::half2int<half::round_style,long long>(arg.data_); }
+        #endif
+
+            /// Decompression implementation.
+            /// \param arg number to decompress
+            /// \param exp address to store exponent at
+            /// \return normalized significant
+            static half frexp(half arg, int *exp)
+            {
+                int m = arg.data_ & 0x7FFF, e = -14;
+                if(m >= 0x7C00 || !m)
+                    return *exp = 0, arg;
+                for(; m<0x400; m<<=1,--e) ;
+                return *exp = e+(m>>10), half(binary, (arg.data_&0x8000)|0x3800|(m&0x3FF));
+            }
+
+            /// Decompression implementation.
+            /// \param arg number to decompress
+            /// \param iptr address to store integer part at
+            /// \return fractional part
+            static half modf(half arg, half *iptr)
+            {
+                unsigned int e = arg.data_ & 0x7FFF;
+                if(e >= 0x6400)
+                    return *iptr = arg, half(binary, arg.data_&(0x8000U|-(e>0x7C00)));
+                if(e < 0x3C00)
+                    return iptr->data_ = arg.data_ & 0x8000, arg;
+                e >>= 10;
+                unsigned int mask = (1<<(25-e)) - 1, m = arg.data_ & mask;
+                iptr->data_ = arg.data_ & ~mask;
+                if(!m)
+                    return half(binary, arg.data_&0x8000);
+                for(; m<0x400; m<<=1,--e) ;
+                return half(binary, static_cast<uint16>((arg.data_&0x8000)|(e<<10)|(m&0x3FF)));
+            }
+
+            /// Scaling implementation.
+            /// \param arg number to scale
+            /// \param exp power of two to scale by
+            /// \return scaled number
+            static half scalbln(half arg, long exp)
+            {
+                unsigned int m = arg.data_ & 0x7FFF;
+                if(m >= 0x7C00 || !m)
+                    return arg;
+                for(; m<0x400; m<<=1,--exp) ;
+                exp += m >> 10;
+                uint16 value = arg.data_ & 0x8000;
+                if(exp > 30)
+                {
+                    if(half::round_style == std::round_toward_zero)
+                        value |= 0x7BFF;
+                    else if(half::round_style == std::round_toward_infinity)
+                        value |= 0x7C00 - (value>>15);
+                    else if(half::round_style == std::round_toward_neg_infinity)
+                        value |= 0x7BFF + (value>>15);
+                    else
+                        value |= 0x7C00;
+                }
+                else if(exp > 0)
+                    value |= (exp<<10) | (m&0x3FF);
+                else if(exp > -11)
+                {
+                    m = (m&0x3FF) | 0x400;
+                    if(half::round_style == std::round_to_nearest)
+                    {
+                        m += 1 << -exp;
+                    #if HALF_ROUND_TIES_TO_EVEN
+                        m -= (m>>(1-exp)) & 1;
+                    #endif
+                    }
+                    else if(half::round_style == std::round_toward_infinity)
+                        m += ((value>>15)-1) & ((1<<(1-exp))-1U);
+                    else if(half::round_style == std::round_toward_neg_infinity)
+                        m += -(value>>15) & ((1<<(1-exp))-1U);
+                    value |= m >> (1-exp);
+                }
+                else if(half::round_style == std::round_toward_infinity)
+                    value -= (value>>15) - 1;
+                else if(half::round_style == std::round_toward_neg_infinity)
+                    value += value >> 15;
+                return half(binary, value);
+            }
+
+            /// Exponent implementation.
+            /// \param arg number to query
+            /// \return floating point exponent
+            static int ilogb(half arg)
+            {
+                int abs = arg.data_ & 0x7FFF;
+                if(!abs)
+                    return FP_ILOGB0;
+                if(abs < 0x7C00)
+                {
+                    int exp = (abs>>10) - 15;
+                    if(abs < 0x400)
+                        for(; abs<0x200; abs<<=1,--exp) ;
+                    return exp;
+                }
+                if(abs > 0x7C00)
+                    return FP_ILOGBNAN;
+                return INT_MAX;
+            }
+
+            /// Exponent implementation.
+            /// \param arg number to query
+            /// \return floating point exponent
+            static half logb(half arg)
+            {
+                int abs = arg.data_ & 0x7FFF;
+                if(!abs)
+                    return half(binary, 0xFC00);
+                if(abs < 0x7C00)
+                {
+                    int exp = (abs>>10) - 15;
+                    if(abs < 0x400)
+                        for(; abs<0x200; abs<<=1,--exp) ;
+                    uint16 bits = (exp<0) << 15;
+                    if(exp)
+                    {
+                        unsigned int m = std::abs(exp) << 6, e = 18;
+                        for(; m<0x400; m<<=1,--e) ;
+                        bits |= (e<<10) + m;
+                    }
+                    return half(binary, bits);
+                }
+                if(abs > 0x7C00)
+                    return arg;
+                return half(binary, 0x7C00);
+            }
+
+            /// Enumeration implementation.
+            /// \param from number to increase/decrease
+            /// \param to direction to enumerate into
+            /// \return next representable number
+            static half nextafter(half from, half to)
+            {
+                uint16 fabs = from.data_ & 0x7FFF, tabs = to.data_ & 0x7FFF;
+                if(fabs > 0x7C00)
+                    return from;
+                if(tabs > 0x7C00 || from.data_ == to.data_ || !(fabs|tabs))
+                    return to;
+                if(!fabs)
+                    return half(binary, (to.data_&0x8000)+1);
+                bool lt = ((fabs==from.data_) ? static_cast<int>(fabs) : -static_cast<int>(fabs)) < 
+                    ((tabs==to.data_) ? static_cast<int>(tabs) : -static_cast<int>(tabs));
+                return half(binary, from.data_+(((from.data_>>15)^static_cast<unsigned>(lt))<<1)-1);
+            }
+
+            /// Enumeration implementation.
+            /// \param from number to increase/decrease
+            /// \param to direction to enumerate into
+            /// \return next representable number
+            static half nexttoward(half from, long double to)
+            {
+                if(isnan(from))
+                    return from;
+                long double lfrom = static_cast<long double>(from);
+                if(builtin_isnan(to) || lfrom == to)
+                    return half(static_cast<float>(to));
+                if(!(from.data_&0x7FFF))
+                    return half(binary, (static_cast<detail::uint16>(builtin_signbit(to))<<15)+1);
+                return half(binary, from.data_+(((from.data_>>15)^static_cast<unsigned>(lfrom<to))<<1)-1);
+            }
+
+            /// Sign implementation
+            /// \param x first operand
+            /// \param y second operand
+            /// \return composed value
+            static half copysign(half x, half y) { return half(binary, x.data_^((x.data_^y.data_)&0x8000)); }
+
+            /// Classification implementation.
+            /// \param arg value to classify
+            /// \retval true if infinite number
+            /// \retval false else
+            static int fpclassify(half arg)
+            {
+                unsigned int abs = arg.data_ & 0x7FFF;
+                return abs ? ((abs>0x3FF) ? ((abs>=0x7C00) ? ((abs>0x7C00) ? FP_NAN : FP_INFINITE) : FP_NORMAL) :FP_SUBNORMAL) : FP_ZERO;
+            }
+
+            /// Classification implementation.
+            /// \param arg value to classify
+            /// \retval true if finite number
+            /// \retval false else
+            static bool isfinite(half arg) { return (arg.data_&0x7C00) != 0x7C00; }
+
+            /// Classification implementation.
+            /// \param arg value to classify
+            /// \retval true if infinite number
+            /// \retval false else
+            static bool isinf(half arg) { return (arg.data_&0x7FFF) == 0x7C00; }
+
+            /// Classification implementation.
+            /// \param arg value to classify
+            /// \retval true if not a number
+            /// \retval false else
+            static bool isnan(half arg) { return (arg.data_&0x7FFF) > 0x7C00; }
+
+            /// Classification implementation.
+            /// \param arg value to classify
+            /// \retval true if normal number
+            /// \retval false else
+            static bool isnormal(half arg) { return ((arg.data_&0x7C00)!=0) & ((arg.data_&0x7C00)!=0x7C00); }
+
+            /// Sign bit implementation.
+            /// \param arg value to check
+            /// \retval true if signed
+            /// \retval false if unsigned
+            static bool signbit(half arg) { return (arg.data_&0x8000) != 0; }
+
+            /// Comparison implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \retval true if operands equal
+            /// \retval false else
+            static bool isequal(half x, half y) { return (x.data_==y.data_ || !((x.data_|y.data_)&0x7FFF)) && !isnan(x); }
+
+            /// Comparison implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \retval true if operands not equal
+            /// \retval false else
+            static bool isnotequal(half x, half y) { return (x.data_!=y.data_ && ((x.data_|y.data_)&0x7FFF)) || isnan(x); }
+
+            /// Comparison implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \retval true if \a x > \a y
+            /// \retval false else
+            static bool isgreater(half x, half y)
+            {
+                int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
+                return xabs<=0x7C00 && yabs<=0x7C00 && (((xabs==x.data_) ? xabs : -xabs) > ((yabs==y.data_) ? yabs : -yabs));
+            }
+
+            /// Comparison implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \retval true if \a x >= \a y
+            /// \retval false else
+            static bool isgreaterequal(half x, half y)
+            {
+                int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
+                return xabs<=0x7C00 && yabs<=0x7C00 && (((xabs==x.data_) ? xabs : -xabs) >= ((yabs==y.data_) ? yabs : -yabs));
+            }
+
+            /// Comparison implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \retval true if \a x < \a y
+            /// \retval false else
+            static bool isless(half x, half y)
+            {
+                int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
+                return xabs<=0x7C00 && yabs<=0x7C00 && (((xabs==x.data_) ? xabs : -xabs) < ((yabs==y.data_) ? yabs : -yabs));
+            }
+
+            /// Comparison implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \retval true if \a x <= \a y
+            /// \retval false else
+            static bool islessequal(half x, half y)
+            {
+                int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
+                return xabs<=0x7C00 && yabs<=0x7C00 && (((xabs==x.data_) ? xabs : -xabs) <= ((yabs==y.data_) ? yabs : -yabs));
+            }
+
+            /// Comparison implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \retval true if either \a x > \a y nor \a x < \a y
+            /// \retval false else
+            static bool islessgreater(half x, half y)
+            {
+                int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
+                if(xabs > 0x7C00 || yabs > 0x7C00)
+                    return false;
+                int a = (xabs==x.data_) ? xabs : -xabs, b = (yabs==y.data_) ? yabs : -yabs;
+                return a < b || a > b;
+            }
+
+            /// Comparison implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \retval true if operand unordered
+            /// \retval false else
+            static bool isunordered(half x, half y) { return isnan(x) || isnan(y); }
+
+        private:
+            static double erf(double arg)
+            {
+                if(builtin_isinf(arg))
+                    return (arg<0.0) ? -1.0 : 1.0;
+                double x2 = arg * arg, ax2 = 0.147 * x2, value = std::sqrt(1.0-std::exp(-x2*(1.2732395447351626861510701069801+ax2)/(1.0+ax2)));
+                return builtin_signbit(arg) ? -value : value;
+            }
+
+            static double lgamma(double arg)
+            {
+                double v = 1.0;
+                for(; arg<8.0; ++arg) v *= arg;
+                double w = 1.0 / (arg*arg);
+                return (((((((-0.02955065359477124183006535947712*w+0.00641025641025641025641025641026)*w+
+                    -0.00191752691752691752691752691753)*w+8.4175084175084175084175084175084e-4)*w+
+                    -5.952380952380952380952380952381e-4)*w+7.9365079365079365079365079365079e-4)*w+
+                    -0.00277777777777777777777777777778)*w+0.08333333333333333333333333333333)/arg + 
+                    0.91893853320467274178032973640562 - std::log(v) - arg + (arg-0.5) * std::log(arg);
+            }
+        };
+
+        /// Wrapper for unary half-precision functions needing specialization for individual argument types.
+        /// \tparam T argument type
+        template<typename T> struct unary_specialized
+        {
+            /// Negation implementation.
+            /// \param arg value to negate
+            /// \return negated value
+            static HALF_CONSTEXPR half negate(half arg) { return half(binary, arg.data_^0x8000); }
+
+            /// Absolute value implementation.
+            /// \param arg function argument
+            /// \return absolute value
+            static half fabs(half arg) { return half(binary, arg.data_&0x7FFF); }
+        };
+        template<> struct unary_specialized<expr>
+        {
+            static HALF_CONSTEXPR expr negate(float arg) { return expr(-arg); }
+            static expr fabs(float arg) { return expr(std::fabs(arg)); }
+        };
+
+        /// Wrapper for binary half-precision functions needing specialization for individual argument types.
+        /// \tparam T first argument type
+        /// \tparam U first argument type
+        template<typename T,typename U> struct binary_specialized
+        {
+            /// Minimum implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \return minimum value
+            static expr fmin(float x, float y)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::fmin(x, y));
+            #else
+                if(builtin_isnan(x))
+                    return expr(y);
+                if(builtin_isnan(y))
+                    return expr(x);
+                return expr(std::min(x, y));
+            #endif
+            }
+
+            /// Maximum implementation.
+            /// \param x first operand
+            /// \param y second operand
+            /// \return maximum value
+            static expr fmax(float x, float y)
+            {
+            #if HALF_ENABLE_CPP11_CMATH
+                return expr(std::fmax(x, y));
+            #else
+                if(builtin_isnan(x))
+                    return expr(y);
+                if(builtin_isnan(y))
+                    return expr(x);
+                return expr(std::max(x, y));
+            #endif
+            }
+        };
+        template<> struct binary_specialized<half,half>
+        {
+            static half fmin(half x, half y)
+            {
+                int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
+                if(xabs > 0x7C00)
+                    return y;
+                if(yabs > 0x7C00)
+                    return x;
+                return (((xabs==x.data_) ? xabs : -xabs) > ((yabs==y.data_) ? yabs : -yabs)) ? y : x;
+            }
+            static half fmax(half x, half y)
+            {
+                int xabs = x.data_ & 0x7FFF, yabs = y.data_ & 0x7FFF;
+                if(xabs > 0x7C00)
+                    return y;
+                if(yabs > 0x7C00)
+                    return x;
+                return (((xabs==x.data_) ? xabs : -xabs) < ((yabs==y.data_) ? yabs : -yabs)) ? y : x;
+            }
+        };
+
+        /// Helper class for half casts.
+        /// This class template has to be specialized for all valid cast argument to define an appropriate static `cast` member 
+        /// function and a corresponding `type` member denoting its return type.
+        /// \tparam T destination type
+        /// \tparam U source type
+        /// \tparam R rounding mode to use
+        template<typename T,typename U,std::float_round_style R=(std::float_round_style)(HALF_ROUND_STYLE)> struct half_caster {};
+        template<typename U,std::float_round_style R> struct half_caster<half,U,R>
+        {
+        #if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
+            static_assert(std::is_arithmetic<U>::value, "half_cast from non-arithmetic type unsupported");
+        #endif
+
+            static half cast(U arg) { return cast_impl(arg, is_float<U>()); };
+
+        private:
+            static half cast_impl(U arg, true_type) { return half(binary, float2half<R>(arg)); }
+            static half cast_impl(U arg, false_type) { return half(binary, int2half<R>(arg)); }
+        };
+        template<typename T,std::float_round_style R> struct half_caster<T,half,R>
+        {
+        #if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
+            static_assert(std::is_arithmetic<T>::value, "half_cast to non-arithmetic type unsupported");
+        #endif
+
+            static T cast(half arg) { return cast_impl(arg, is_float<T>()); }
+
+        private:
+            static T cast_impl(half arg, true_type) { return half2float<T>(arg.data_); }
+            static T cast_impl(half arg, false_type) { return half2int<R,T>(arg.data_); }
+        };
+        template<typename T,std::float_round_style R> struct half_caster<T,expr,R>
+        {
+        #if HALF_ENABLE_CPP11_STATIC_ASSERT && HALF_ENABLE_CPP11_TYPE_TRAITS
+            static_assert(std::is_arithmetic<T>::value, "half_cast to non-arithmetic type unsupported");
+        #endif
+
+            static T cast(expr arg) { return cast_impl(arg, is_float<T>()); }
+
+        private:
+            static T cast_impl(float arg, true_type) { return static_cast<T>(arg); }
+            static T cast_impl(half arg, false_type) { return half2int<R,T>(arg.data_); }
+        };
+        template<std::float_round_style R> struct half_caster<half,half,R>
+        {
+            static half cast(half arg) { return arg; }
+        };
+        template<std::float_round_style R> struct half_caster<half,expr,R> : half_caster<half,half,R> {};
+
+        /// \name Comparison operators
+        /// \{
+
+        /// Comparison for equality.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if operands equal
+        /// \retval false else
+        template<typename T,typename U> typename enable<bool,T,U>::type operator==(T x, U y) { return functions::isequal(x, y); }
+
+        /// Comparison for inequality.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if operands not equal
+        /// \retval false else
+        template<typename T,typename U> typename enable<bool,T,U>::type operator!=(T x, U y) { return functions::isnotequal(x, y); }
+
+        /// Comparison for less than.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if \a x less than \a y
+        /// \retval false else
+        template<typename T,typename U> typename enable<bool,T,U>::type operator<(T x, U y) { return functions::isless(x, y); }
+
+        /// Comparison for greater than.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if \a x greater than \a y
+        /// \retval false else
+        template<typename T,typename U> typename enable<bool,T,U>::type operator>(T x, U y) { return functions::isgreater(x, y); }
+
+        /// Comparison for less equal.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if \a x less equal \a y
+        /// \retval false else
+        template<typename T,typename U> typename enable<bool,T,U>::type operator<=(T x, U y) { return functions::islessequal(x, y); }
+
+        /// Comparison for greater equal.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if \a x greater equal \a y
+        /// \retval false else
+        template<typename T,typename U> typename enable<bool,T,U>::type operator>=(T x, U y) { return functions::isgreaterequal(x, y); }
+
+        /// \}
+        /// \name Arithmetic operators
+        /// \{
+
+        /// Add halfs.
+        /// \param x left operand
+        /// \param y right operand
+        /// \return sum of half expressions
+        template<typename T,typename U> typename enable<expr,T,U>::type operator+(T x, U y) { return functions::plus(x, y); }
+
+        /// Subtract halfs.
+        /// \param x left operand
+        /// \param y right operand
+        /// \return difference of half expressions
+        template<typename T,typename U> typename enable<expr,T,U>::type operator-(T x, U y) { return functions::minus(x, y); }
+
+        /// Multiply halfs.
+        /// \param x left operand
+        /// \param y right operand
+        /// \return product of half expressions
+        template<typename T,typename U> typename enable<expr,T,U>::type operator*(T x, U y) { return functions::multiplies(x, y); }
+
+        /// Divide halfs.
+        /// \param x left operand
+        /// \param y right operand
+        /// \return quotient of half expressions
+        template<typename T,typename U> typename enable<expr,T,U>::type operator/(T x, U y) { return functions::divides(x, y); }
+
+        /// Identity.
+        /// \param arg operand
+        /// \return uncahnged operand
+        template<typename T> HALF_CONSTEXPR typename enable<T,T>::type operator+(T arg) { return arg; }
+
+        /// Negation.
+        /// \param arg operand
+        /// \return negated operand
+        template<typename T> HALF_CONSTEXPR typename enable<T,T>::type operator-(T arg) { return unary_specialized<T>::negate(arg); }
+
+        /// \}
+        /// \name Input and output
+        /// \{
+
+        /// Output operator.
+        /// \param out output stream to write into
+        /// \param arg half expression to write
+        /// \return reference to output stream
+        template<typename T,typename charT,typename traits> typename enable<std::basic_ostream<charT,traits>&,T>::type
+            operator<<(std::basic_ostream<charT,traits> &out, T arg) { return functions::write(out, arg); }
+
+        /// Input operator.
+        /// \param in input stream to read from
+        /// \param arg half to read into
+        /// \return reference to input stream
+        template<typename charT,typename traits> std::basic_istream<charT,traits>&
+            operator>>(std::basic_istream<charT,traits> &in, half &arg) { return functions::read(in, arg); }
+
+        /// \}
+        /// \name Basic mathematical operations
+        /// \{
+
+        /// Absolute value.
+        /// \param arg operand
+        /// \return absolute value of \a arg
 //		template<typename T> typename enable<T,T>::type abs(T arg) { return unary_specialized<T>::fabs(arg); }
-		inline half abs(half arg) { return unary_specialized<half>::fabs(arg); }
-		inline expr abs(expr arg) { return unary_specialized<expr>::fabs(arg); }
+        inline half abs(half arg) { return unary_specialized<half>::fabs(arg); }
+        inline expr abs(expr arg) { return unary_specialized<expr>::fabs(arg); }
 
-		/// Absolute value.
-		/// \param arg operand
-		/// \return absolute value of \a arg
+        /// Absolute value.
+        /// \param arg operand
+        /// \return absolute value of \a arg
 //		template<typename T> typename enable<T,T>::type fabs(T arg) { return unary_specialized<T>::fabs(arg); }
-		inline half fabs(half arg) { return unary_specialized<half>::fabs(arg); }
-		inline expr fabs(expr arg) { return unary_specialized<expr>::fabs(arg); }
+        inline half fabs(half arg) { return unary_specialized<half>::fabs(arg); }
+        inline expr fabs(expr arg) { return unary_specialized<expr>::fabs(arg); }
 
-		/// Remainder of division.
-		/// \param x first operand
-		/// \param y second operand
-		/// \return remainder of floating point division.
+        /// Remainder of division.
+        /// \param x first operand
+        /// \param y second operand
+        /// \return remainder of floating point division.
 //		template<typename T,typename U> typename enable<expr,T,U>::type fmod(T x, U y) { return functions::fmod(x, y); }
-		inline expr fmod(half x, half y) { return functions::fmod(x, y); }
-		inline expr fmod(half x, expr y) { return functions::fmod(x, y); }
-		inline expr fmod(expr x, half y) { return functions::fmod(x, y); }
-		inline expr fmod(expr x, expr y) { return functions::fmod(x, y); }
-
-		/// Remainder of division.
-		/// \param x first operand
-		/// \param y second operand
-		/// \return remainder of floating point division.
+        inline expr fmod(half x, half y) { return functions::fmod(x, y); }
+        inline expr fmod(half x, expr y) { return functions::fmod(x, y); }
+        inline expr fmod(expr x, half y) { return functions::fmod(x, y); }
+        inline expr fmod(expr x, expr y) { return functions::fmod(x, y); }
+
+        /// Remainder of division.
+        /// \param x first operand
+        /// \param y second operand
+        /// \return remainder of floating point division.
 //		template<typename T,typename U> typename enable<expr,T,U>::type remainder(T x, U y) { return functions::remainder(x, y); }
-		inline expr remainder(half x, half y) { return functions::remainder(x, y); }
-		inline expr remainder(half x, expr y) { return functions::remainder(x, y); }
-		inline expr remainder(expr x, half y) { return functions::remainder(x, y); }
-		inline expr remainder(expr x, expr y) { return functions::remainder(x, y); }
-
-		/// Remainder of division.
-		/// \param x first operand
-		/// \param y second operand
-		/// \param quo address to store some bits of quotient at
-		/// \return remainder of floating point division.
+        inline expr remainder(half x, half y) { return functions::remainder(x, y); }
+        inline expr remainder(half x, expr y) { return functions::remainder(x, y); }
+        inline expr remainder(expr x, half y) { return functions::remainder(x, y); }
+        inline expr remainder(expr x, expr y) { return functions::remainder(x, y); }
+
+        /// Remainder of division.
+        /// \param x first operand
+        /// \param y second operand
+        /// \param quo address to store some bits of quotient at
+        /// \return remainder of floating point division.
 //		template<typename T,typename U> typename enable<expr,T,U>::type remquo(T x, U y, int *quo) { return functions::remquo(x, y, quo); }
-		inline expr remquo(half x, half y, int *quo) { return functions::remquo(x, y, quo); }
-		inline expr remquo(half x, expr y, int *quo) { return functions::remquo(x, y, quo); }
-		inline expr remquo(expr x, half y, int *quo) { return functions::remquo(x, y, quo); }
-		inline expr remquo(expr x, expr y, int *quo) { return functions::remquo(x, y, quo); }
-
-		/// Fused multiply add.
-		/// \param x first operand
-		/// \param y second operand
-		/// \param z third operand
-		/// \return ( \a x * \a y ) + \a z rounded as one operation.
+        inline expr remquo(half x, half y, int *quo) { return functions::remquo(x, y, quo); }
+        inline expr remquo(half x, expr y, int *quo) { return functions::remquo(x, y, quo); }
+        inline expr remquo(expr x, half y, int *quo) { return functions::remquo(x, y, quo); }
+        inline expr remquo(expr x, expr y, int *quo) { return functions::remquo(x, y, quo); }
+
+        /// Fused multiply add.
+        /// \param x first operand
+        /// \param y second operand
+        /// \param z third operand
+        /// \return ( \a x * \a y ) + \a z rounded as one operation.
 //		template<typename T,typename U,typename V> typename enable<expr,T,U,V>::type fma(T x, U y, V z) { return functions::fma(x, y, z); }
-		inline expr fma(half x, half y, half z) { return functions::fma(x, y, z); }
-		inline expr fma(half x, half y, expr z) { return functions::fma(x, y, z); }
-		inline expr fma(half x, expr y, half z) { return functions::fma(x, y, z); }
-		inline expr fma(half x, expr y, expr z) { return functions::fma(x, y, z); }
-		inline expr fma(expr x, half y, half z) { return functions::fma(x, y, z); }
-		inline expr fma(expr x, half y, expr z) { return functions::fma(x, y, z); }
-		inline expr fma(expr x, expr y, half z) { return functions::fma(x, y, z); }
-		inline expr fma(expr x, expr y, expr z) { return functions::fma(x, y, z); }
-
-		/// Maximum of half expressions.
-		/// \param x first operand
-		/// \param y second operand
-		/// \return maximum of operands
+        inline expr fma(half x, half y, half z) { return functions::fma(x, y, z); }
+        inline expr fma(half x, half y, expr z) { return functions::fma(x, y, z); }
+        inline expr fma(half x, expr y, half z) { return functions::fma(x, y, z); }
+        inline expr fma(half x, expr y, expr z) { return functions::fma(x, y, z); }
+        inline expr fma(expr x, half y, half z) { return functions::fma(x, y, z); }
+        inline expr fma(expr x, half y, expr z) { return functions::fma(x, y, z); }
+        inline expr fma(expr x, expr y, half z) { return functions::fma(x, y, z); }
+        inline expr fma(expr x, expr y, expr z) { return functions::fma(x, y, z); }
+
+        /// Maximum of half expressions.
+        /// \param x first operand
+        /// \param y second operand
+        /// \return maximum of operands
 //		template<typename T,typename U> typename result<T,U>::type fmax(T x, U y) { return binary_specialized<T,U>::fmax(x, y); }
-		inline half fmax(half x, half y) { return binary_specialized<half,half>::fmax(x, y); }
-		inline expr fmax(half x, expr y) { return binary_specialized<half,expr>::fmax(x, y); }
-		inline expr fmax(expr x, half y) { return binary_specialized<expr,half>::fmax(x, y); }
-		inline expr fmax(expr x, expr y) { return binary_specialized<expr,expr>::fmax(x, y); }
-
-		/// Minimum of half expressions.
-		/// \param x first operand
-		/// \param y second operand
-		/// \return minimum of operands
+        inline half fmax(half x, half y) { return binary_specialized<half,half>::fmax(x, y); }
+        inline expr fmax(half x, expr y) { return binary_specialized<half,expr>::fmax(x, y); }
+        inline expr fmax(expr x, half y) { return binary_specialized<expr,half>::fmax(x, y); }
+        inline expr fmax(expr x, expr y) { return binary_specialized<expr,expr>::fmax(x, y); }
+
+        /// Minimum of half expressions.
+        /// \param x first operand
+        /// \param y second operand
+        /// \return minimum of operands
 //		template<typename T,typename U> typename result<T,U>::type fmin(T x, U y) { return binary_specialized<T,U>::fmin(x, y); }
-		inline half fmin(half x, half y) { return binary_specialized<half,half>::fmin(x, y); }
-		inline expr fmin(half x, expr y) { return binary_specialized<half,expr>::fmin(x, y); }
-		inline expr fmin(expr x, half y) { return binary_specialized<expr,half>::fmin(x, y); }
-		inline expr fmin(expr x, expr y) { return binary_specialized<expr,expr>::fmin(x, y); }
-
-		/// Positive difference.
-		/// \param x first operand
-		/// \param y second operand
-		/// \return \a x - \a y or 0 if difference negative
+        inline half fmin(half x, half y) { return binary_specialized<half,half>::fmin(x, y); }
+        inline expr fmin(half x, expr y) { return binary_specialized<half,expr>::fmin(x, y); }
+        inline expr fmin(expr x, half y) { return binary_specialized<expr,half>::fmin(x, y); }
+        inline expr fmin(expr x, expr y) { return binary_specialized<expr,expr>::fmin(x, y); }
+
+        /// Positive difference.
+        /// \param x first operand
+        /// \param y second operand
+        /// \return \a x - \a y or 0 if difference negative
 //		template<typename T,typename U> typename enable<expr,T,U>::type fdim(T x, U y) { return functions::fdim(x, y); }
-		inline expr fdim(half x, half y) { return functions::fdim(x, y); }
-		inline expr fdim(half x, expr y) { return functions::fdim(x, y); }
-		inline expr fdim(expr x, half y) { return functions::fdim(x, y); }
-		inline expr fdim(expr x, expr y) { return functions::fdim(x, y); }
-
-		/// Get NaN value.
-		/// \return quiet NaN
-		inline half nanh(const char*) { return functions::nanh(); }
-
-		/// \}
-		/// \name Exponential functions
-		/// \{
-
-		/// Exponential function.
-		/// \param arg function argument
-		/// \return e raised to \a arg
+        inline expr fdim(half x, half y) { return functions::fdim(x, y); }
+        inline expr fdim(half x, expr y) { return functions::fdim(x, y); }
+        inline expr fdim(expr x, half y) { return functions::fdim(x, y); }
+        inline expr fdim(expr x, expr y) { return functions::fdim(x, y); }
+
+        /// Get NaN value.
+        /// \return quiet NaN
+        inline half nanh(const char*) { return functions::nanh(); }
+
+        /// \}
+        /// \name Exponential functions
+        /// \{
+
+        /// Exponential function.
+        /// \param arg function argument
+        /// \return e raised to \a arg
 //		template<typename T> typename enable<expr,T>::type exp(T arg) { return functions::exp(arg); }
-		inline expr exp(half arg) { return functions::exp(arg); }
-		inline expr exp(expr arg) { return functions::exp(arg); }
+        inline expr exp(half arg) { return functions::exp(arg); }
+        inline expr exp(expr arg) { return functions::exp(arg); }
 
-		/// Exponential minus one.
-		/// \param arg function argument
-		/// \return e raised to \a arg subtracted by 1
+        /// Exponential minus one.
+        /// \param arg function argument
+        /// \return e raised to \a arg subtracted by 1
 //		template<typename T> typename enable<expr,T>::type expm1(T arg) { return functions::expm1(arg); }
-		inline expr expm1(half arg) { return functions::expm1(arg); }
-		inline expr expm1(expr arg) { return functions::expm1(arg); }
+        inline expr expm1(half arg) { return functions::expm1(arg); }
+        inline expr expm1(expr arg) { return functions::expm1(arg); }
 
-		/// Binary exponential.
-		/// \param arg function argument
-		/// \return 2 raised to \a arg
+        /// Binary exponential.
+        /// \param arg function argument
+        /// \return 2 raised to \a arg
 //		template<typename T> typename enable<expr,T>::type exp2(T arg) { return functions::exp2(arg); }
-		inline expr exp2(half arg) { return functions::exp2(arg); }
-		inline expr exp2(expr arg) { return functions::exp2(arg); }
+        inline expr exp2(half arg) { return functions::exp2(arg); }
+        inline expr exp2(expr arg) { return functions::exp2(arg); }
 
-		/// Natural logorithm.
-		/// \param arg function argument
-		/// \return logarithm of \a arg to base e
+        /// Natural logorithm.
+        /// \param arg function argument
+        /// \return logarithm of \a arg to base e
 //		template<typename T> typename enable<expr,T>::type log(T arg) { return functions::log(arg); }
-		inline expr log(half arg) { return functions::log(arg); }
-		inline expr log(expr arg) { return functions::log(arg); }
+        inline expr log(half arg) { return functions::log(arg); }
+        inline expr log(expr arg) { return functions::log(arg); }
 
-		/// Common logorithm.
-		/// \param arg function argument
-		/// \return logarithm of \a arg to base 10
+        /// Common logorithm.
+        /// \param arg function argument
+        /// \return logarithm of \a arg to base 10
 //		template<typename T> typename enable<expr,T>::type log10(T arg) { return functions::log10(arg); }
-		inline expr log10(half arg) { return functions::log10(arg); }
-		inline expr log10(expr arg) { return functions::log10(arg); }
+        inline expr log10(half arg) { return functions::log10(arg); }
+        inline expr log10(expr arg) { return functions::log10(arg); }
 
-		/// Natural logorithm.
-		/// \param arg function argument
-		/// \return logarithm of \a arg plus 1 to base e
+        /// Natural logorithm.
+        /// \param arg function argument
+        /// \return logarithm of \a arg plus 1 to base e
 //		template<typename T> typename enable<expr,T>::type log1p(T arg) { return functions::log1p(arg); }
-		inline expr log1p(half arg) { return functions::log1p(arg); }
-		inline expr log1p(expr arg) { return functions::log1p(arg); }
+        inline expr log1p(half arg) { return functions::log1p(arg); }
+        inline expr log1p(expr arg) { return functions::log1p(arg); }
 
-		/// Binary logorithm.
-		/// \param arg function argument
-		/// \return logarithm of \a arg to base 2
+        /// Binary logorithm.
+        /// \param arg function argument
+        /// \return logarithm of \a arg to base 2
 //		template<typename T> typename enable<expr,T>::type log2(T arg) { return functions::log2(arg); }
-		inline expr log2(half arg) { return functions::log2(arg); }
-		inline expr log2(expr arg) { return functions::log2(arg); }
+        inline expr log2(half arg) { return functions::log2(arg); }
+        inline expr log2(expr arg) { return functions::log2(arg); }
 
-		/// \}
-		/// \name Power functions
-		/// \{
+        /// \}
+        /// \name Power functions
+        /// \{
 
-		/// Square root.
-		/// \param arg function argument
-		/// \return square root of \a arg
+        /// Square root.
+        /// \param arg function argument
+        /// \return square root of \a arg
 //		template<typename T> typename enable<expr,T>::type sqrt(T arg) { return functions::sqrt(arg); }
-		inline expr sqrt(half arg) { return functions::sqrt(arg); }
-		inline expr sqrt(expr arg) { return functions::sqrt(arg); }
+        inline expr sqrt(half arg) { return functions::sqrt(arg); }
+        inline expr sqrt(expr arg) { return functions::sqrt(arg); }
 
-		/// Cubic root.
-		/// \param arg function argument
-		/// \return cubic root of \a arg
+        /// Cubic root.
+        /// \param arg function argument
+        /// \return cubic root of \a arg
 //		template<typename T> typename enable<expr,T>::type cbrt(T arg) { return functions::cbrt(arg); }
-		inline expr cbrt(half arg) { return functions::cbrt(arg); }
-		inline expr cbrt(expr arg) { return functions::cbrt(arg); }
+        inline expr cbrt(half arg) { return functions::cbrt(arg); }
+        inline expr cbrt(expr arg) { return functions::cbrt(arg); }
 
-		/// Hypotenuse function.
-		/// \param x first argument
-		/// \param y second argument
-		/// \return square root of sum of squares without internal over- or underflows
+        /// Hypotenuse function.
+        /// \param x first argument
+        /// \param y second argument
+        /// \return square root of sum of squares without internal over- or underflows
 //		template<typename T,typename U> typename enable<expr,T,U>::type hypot(T x, U y) { return functions::hypot(x, y); }
-		inline expr hypot(half x, half y) { return functions::hypot(x, y); }
-		inline expr hypot(half x, expr y) { return functions::hypot(x, y); }
-		inline expr hypot(expr x, half y) { return functions::hypot(x, y); }
-		inline expr hypot(expr x, expr y) { return functions::hypot(x, y); }
-
-		/// Power function.
-		/// \param base first argument
-		/// \param exp second argument
-		/// \return \a base raised to \a exp
+        inline expr hypot(half x, half y) { return functions::hypot(x, y); }
+        inline expr hypot(half x, expr y) { return functions::hypot(x, y); }
+        inline expr hypot(expr x, half y) { return functions::hypot(x, y); }
+        inline expr hypot(expr x, expr y) { return functions::hypot(x, y); }
+
+        /// Power function.
+        /// \param base first argument
+        /// \param exp second argument
+        /// \return \a base raised to \a exp
 //		template<typename T,typename U> typename enable<expr,T,U>::type pow(T base, U exp) { return functions::pow(base, exp); }
-		inline expr pow(half base, half exp) { return functions::pow(base, exp); }
-		inline expr pow(half base, expr exp) { return functions::pow(base, exp); }
-		inline expr pow(expr base, half exp) { return functions::pow(base, exp); }
-		inline expr pow(expr base, expr exp) { return functions::pow(base, exp); }
-
-		/// \}
-		/// \name Trigonometric functions
-		/// \{
-
-		/// Sine function.
-		/// \param arg function argument
-		/// \return sine value of \a arg
+        inline expr pow(half base, half exp) { return functions::pow(base, exp); }
+        inline expr pow(half base, expr exp) { return functions::pow(base, exp); }
+        inline expr pow(expr base, half exp) { return functions::pow(base, exp); }
+        inline expr pow(expr base, expr exp) { return functions::pow(base, exp); }
+
+        /// \}
+        /// \name Trigonometric functions
+        /// \{
+
+        /// Sine function.
+        /// \param arg function argument
+        /// \return sine value of \a arg
 //		template<typename T> typename enable<expr,T>::type sin(T arg) { return functions::sin(arg); }
-		inline expr sin(half arg) { return functions::sin(arg); }
-		inline expr sin(expr arg) { return functions::sin(arg); }
+        inline expr sin(half arg) { return functions::sin(arg); }
+        inline expr sin(expr arg) { return functions::sin(arg); }
 
-		/// Cosine function.
-		/// \param arg function argument
-		/// \return cosine value of \a arg
+        /// Cosine function.
+        /// \param arg function argument
+        /// \return cosine value of \a arg
 //		template<typename T> typename enable<expr,T>::type cos(T arg) { return functions::cos(arg); }
-		inline expr cos(half arg) { return functions::cos(arg); }
-		inline expr cos(expr arg) { return functions::cos(arg); }
+        inline expr cos(half arg) { return functions::cos(arg); }
+        inline expr cos(expr arg) { return functions::cos(arg); }
 
-		/// Tangent function.
-		/// \param arg function argument
-		/// \return tangent value of \a arg
+        /// Tangent function.
+        /// \param arg function argument
+        /// \return tangent value of \a arg
 //		template<typename T> typename enable<expr,T>::type tan(T arg) { return functions::tan(arg); }
-		inline expr tan(half arg) { return functions::tan(arg); }
-		inline expr tan(expr arg) { return functions::tan(arg); }
+        inline expr tan(half arg) { return functions::tan(arg); }
+        inline expr tan(expr arg) { return functions::tan(arg); }
 
-		/// Arc sine.
-		/// \param arg function argument
-		/// \return arc sine value of \a arg
+        /// Arc sine.
+        /// \param arg function argument
+        /// \return arc sine value of \a arg
 //		template<typename T> typename enable<expr,T>::type asin(T arg) { return functions::asin(arg); }
-		inline expr asin(half arg) { return functions::asin(arg); }
-		inline expr asin(expr arg) { return functions::asin(arg); }
+        inline expr asin(half arg) { return functions::asin(arg); }
+        inline expr asin(expr arg) { return functions::asin(arg); }
 
-		/// Arc cosine function.
-		/// \param arg function argument
-		/// \return arc cosine value of \a arg
+        /// Arc cosine function.
+        /// \param arg function argument
+        /// \return arc cosine value of \a arg
 //		template<typename T> typename enable<expr,T>::type acos(T arg) { return functions::acos(arg); }
-		inline expr acos(half arg) { return functions::acos(arg); }
-		inline expr acos(expr arg) { return functions::acos(arg); }
+        inline expr acos(half arg) { return functions::acos(arg); }
+        inline expr acos(expr arg) { return functions::acos(arg); }
 
-		/// Arc tangent function.
-		/// \param arg function argument
-		/// \return arc tangent value of \a arg
+        /// Arc tangent function.
+        /// \param arg function argument
+        /// \return arc tangent value of \a arg
 //		template<typename T> typename enable<expr,T>::type atan(T arg) { return functions::atan(arg); }
-		inline expr atan(half arg) { return functions::atan(arg); }
-		inline expr atan(expr arg) { return functions::atan(arg); }
+        inline expr atan(half arg) { return functions::atan(arg); }
+        inline expr atan(expr arg) { return functions::atan(arg); }
 
-		/// Arc tangent function.
-		/// \param x first argument
-		/// \param y second argument
-		/// \return arc tangent value
+        /// Arc tangent function.
+        /// \param x first argument
+        /// \param y second argument
+        /// \return arc tangent value
 //		template<typename T,typename U> typename enable<expr,T,U>::type atan2(T x, U y) { return functions::atan2(x, y); }
-		inline expr atan2(half x, half y) { return functions::atan2(x, y); }
-		inline expr atan2(half x, expr y) { return functions::atan2(x, y); }
-		inline expr atan2(expr x, half y) { return functions::atan2(x, y); }
-		inline expr atan2(expr x, expr y) { return functions::atan2(x, y); }
-
-		/// \}
-		/// \name Hyperbolic functions
-		/// \{
-
-		/// Hyperbolic sine.
-		/// \param arg function argument
-		/// \return hyperbolic sine value of \a arg
+        inline expr atan2(half x, half y) { return functions::atan2(x, y); }
+        inline expr atan2(half x, expr y) { return functions::atan2(x, y); }
+        inline expr atan2(expr x, half y) { return functions::atan2(x, y); }
+        inline expr atan2(expr x, expr y) { return functions::atan2(x, y); }
+
+        /// \}
+        /// \name Hyperbolic functions
+        /// \{
+
+        /// Hyperbolic sine.
+        /// \param arg function argument
+        /// \return hyperbolic sine value of \a arg
 //		template<typename T> typename enable<expr,T>::type sinh(T arg) { return functions::sinh(arg); }
-		inline expr sinh(half arg) { return functions::sinh(arg); }
-		inline expr sinh(expr arg) { return functions::sinh(arg); }
+        inline expr sinh(half arg) { return functions::sinh(arg); }
+        inline expr sinh(expr arg) { return functions::sinh(arg); }
 
-		/// Hyperbolic cosine.
-		/// \param arg function argument
-		/// \return hyperbolic cosine value of \a arg
+        /// Hyperbolic cosine.
+        /// \param arg function argument
+        /// \return hyperbolic cosine value of \a arg
 //		template<typename T> typename enable<expr,T>::type cosh(T arg) { return functions::cosh(arg); }
-		inline expr cosh(half arg) { return functions::cosh(arg); }
-		inline expr cosh(expr arg) { return functions::cosh(arg); }
+        inline expr cosh(half arg) { return functions::cosh(arg); }
+        inline expr cosh(expr arg) { return functions::cosh(arg); }
 
-		/// Hyperbolic tangent.
-		/// \param arg function argument
-		/// \return hyperbolic tangent value of \a arg
+        /// Hyperbolic tangent.
+        /// \param arg function argument
+        /// \return hyperbolic tangent value of \a arg
 //		template<typename T> typename enable<expr,T>::type tanh(T arg) { return functions::tanh(arg); }
-		inline expr tanh(half arg) { return functions::tanh(arg); }
-		inline expr tanh(expr arg) { return functions::tanh(arg); }
+        inline expr tanh(half arg) { return functions::tanh(arg); }
+        inline expr tanh(expr arg) { return functions::tanh(arg); }
 
-		/// Hyperbolic area sine.
-		/// \param arg function argument
-		/// \return area sine value of \a arg
+        /// Hyperbolic area sine.
+        /// \param arg function argument
+        /// \return area sine value of \a arg
 //		template<typename T> typename enable<expr,T>::type asinh(T arg) { return functions::asinh(arg); }
-		inline expr asinh(half arg) { return functions::asinh(arg); }
-		inline expr asinh(expr arg) { return functions::asinh(arg); }
+        inline expr asinh(half arg) { return functions::asinh(arg); }
+        inline expr asinh(expr arg) { return functions::asinh(arg); }
 
-		/// Hyperbolic area cosine.
-		/// \param arg function argument
-		/// \return area cosine value of \a arg
+        /// Hyperbolic area cosine.
+        /// \param arg function argument
+        /// \return area cosine value of \a arg
 //		template<typename T> typename enable<expr,T>::type acosh(T arg) { return functions::acosh(arg); }
-		inline expr acosh(half arg) { return functions::acosh(arg); }
-		inline expr acosh(expr arg) { return functions::acosh(arg); }
+        inline expr acosh(half arg) { return functions::acosh(arg); }
+        inline expr acosh(expr arg) { return functions::acosh(arg); }
 
-		/// Hyperbolic area tangent.
-		/// \param arg function argument
-		/// \return area tangent value of \a arg
+        /// Hyperbolic area tangent.
+        /// \param arg function argument
+        /// \return area tangent value of \a arg
 //		template<typename T> typename enable<expr,T>::type atanh(T arg) { return functions::atanh(arg); }
-		inline expr atanh(half arg) { return functions::atanh(arg); }
-		inline expr atanh(expr arg) { return functions::atanh(arg); }
+        inline expr atanh(half arg) { return functions::atanh(arg); }
+        inline expr atanh(expr arg) { return functions::atanh(arg); }
 
-		/// \}
-		/// \name Error and gamma functions
-		/// \{
+        /// \}
+        /// \name Error and gamma functions
+        /// \{
 
-		/// Error function.
-		/// \param arg function argument
-		/// \return error function value of \a arg
+        /// Error function.
+        /// \param arg function argument
+        /// \return error function value of \a arg
 //		template<typename T> typename enable<expr,T>::type erf(T arg) { return functions::erf(arg); }
-		inline expr erf(half arg) { return functions::erf(arg); }
-		inline expr erf(expr arg) { return functions::erf(arg); }
+        inline expr erf(half arg) { return functions::erf(arg); }
+        inline expr erf(expr arg) { return functions::erf(arg); }
 
-		/// Complementary error function.
-		/// \param arg function argument
-		/// \return 1 minus error function value of \a arg
+        /// Complementary error function.
+        /// \param arg function argument
+        /// \return 1 minus error function value of \a arg
 //		template<typename T> typename enable<expr,T>::type erfc(T arg) { return functions::erfc(arg); }
-		inline expr erfc(half arg) { return functions::erfc(arg); }
-		inline expr erfc(expr arg) { return functions::erfc(arg); }
+        inline expr erfc(half arg) { return functions::erfc(arg); }
+        inline expr erfc(expr arg) { return functions::erfc(arg); }
 
-		/// Natural logarithm of gamma function.
-		/// \param arg function argument
-		/// \return natural logarith of gamma function for \a arg
+        /// Natural logarithm of gamma function.
+        /// \param arg function argument
+        /// \return natural logarith of gamma function for \a arg
 //		template<typename T> typename enable<expr,T>::type lgamma(T arg) { return functions::lgamma(arg); }
-		inline expr lgamma(half arg) { return functions::lgamma(arg); }
-		inline expr lgamma(expr arg) { return functions::lgamma(arg); }
+        inline expr lgamma(half arg) { return functions::lgamma(arg); }
+        inline expr lgamma(expr arg) { return functions::lgamma(arg); }
 
-		/// Gamma function.
-		/// \param arg function argument
-		/// \return gamma function value of \a arg
+        /// Gamma function.
+        /// \param arg function argument
+        /// \return gamma function value of \a arg
 //		template<typename T> typename enable<expr,T>::type tgamma(T arg) { return functions::tgamma(arg); }
-		inline expr tgamma(half arg) { return functions::tgamma(arg); }
-		inline expr tgamma(expr arg) { return functions::tgamma(arg); }
+        inline expr tgamma(half arg) { return functions::tgamma(arg); }
+        inline expr tgamma(expr arg) { return functions::tgamma(arg); }
 
-		/// \}
-		/// \name Rounding
-		/// \{
+        /// \}
+        /// \name Rounding
+        /// \{
 
-		/// Nearest integer not less than half value.
-		/// \param arg half to round
-		/// \return nearest integer not less than \a arg
+        /// Nearest integer not less than half value.
+        /// \param arg half to round
+        /// \return nearest integer not less than \a arg
 //		template<typename T> typename enable<half,T>::type ceil(T arg) { return functions::ceil(arg); }
-		inline half ceil(half arg) { return functions::ceil(arg); }
-		inline half ceil(expr arg) { return functions::ceil(arg); }
+        inline half ceil(half arg) { return functions::ceil(arg); }
+        inline half ceil(expr arg) { return functions::ceil(arg); }
 
-		/// Nearest integer not greater than half value.
-		/// \param arg half to round
-		/// \return nearest integer not greater than \a arg
+        /// Nearest integer not greater than half value.
+        /// \param arg half to round
+        /// \return nearest integer not greater than \a arg
 //		template<typename T> typename enable<half,T>::type floor(T arg) { return functions::floor(arg); }
-		inline half floor(half arg) { return functions::floor(arg); }
-		inline half floor(expr arg) { return functions::floor(arg); }
+        inline half floor(half arg) { return functions::floor(arg); }
+        inline half floor(expr arg) { return functions::floor(arg); }
 
-		/// Nearest integer not greater in magnitude than half value.
-		/// \param arg half to round
-		/// \return nearest integer not greater in magnitude than \a arg
+        /// Nearest integer not greater in magnitude than half value.
+        /// \param arg half to round
+        /// \return nearest integer not greater in magnitude than \a arg
 //		template<typename T> typename enable<half,T>::type trunc(T arg) { return functions::trunc(arg); }
-		inline half trunc(half arg) { return functions::trunc(arg); }
-		inline half trunc(expr arg) { return functions::trunc(arg); }
+        inline half trunc(half arg) { return functions::trunc(arg); }
+        inline half trunc(expr arg) { return functions::trunc(arg); }
 
-		/// Nearest integer.
-		/// \param arg half to round
-		/// \return nearest integer, rounded away from zero in half-way cases
+        /// Nearest integer.
+        /// \param arg half to round
+        /// \return nearest integer, rounded away from zero in half-way cases
 //		template<typename T> typename enable<half,T>::type round(T arg) { return functions::round(arg); }
-		inline half round(half arg) { return functions::round(arg); }
-		inline half round(expr arg) { return functions::round(arg); }
+        inline half round(half arg) { return functions::round(arg); }
+        inline half round(expr arg) { return functions::round(arg); }
 
-		/// Nearest integer.
-		/// \param arg half to round
-		/// \return nearest integer, rounded away from zero in half-way cases
+        /// Nearest integer.
+        /// \param arg half to round
+        /// \return nearest integer, rounded away from zero in half-way cases
 //		template<typename T> typename enable<long,T>::type lround(T arg) { return functions::lround(arg); }
-		inline long lround(half arg) { return functions::lround(arg); }
-		inline long lround(expr arg) { return functions::lround(arg); }
+        inline long lround(half arg) { return functions::lround(arg); }
+        inline long lround(expr arg) { return functions::lround(arg); }
 
-		/// Nearest integer using half's internal rounding mode.
-		/// \param arg half expression to round
-		/// \return nearest integer using default rounding mode
+        /// Nearest integer using half's internal rounding mode.
+        /// \param arg half expression to round
+        /// \return nearest integer using default rounding mode
 //		template<typename T> typename enable<half,T>::type nearbyint(T arg) { return functions::nearbyint(arg); }
-		inline half nearbyint(half arg) { return functions::rint(arg); }
-		inline half nearbyint(expr arg) { return functions::rint(arg); }
+        inline half nearbyint(half arg) { return functions::rint(arg); }
+        inline half nearbyint(expr arg) { return functions::rint(arg); }
 
-		/// Nearest integer using half's internal rounding mode.
-		/// \param arg half expression to round
-		/// \return nearest integer using default rounding mode
+        /// Nearest integer using half's internal rounding mode.
+        /// \param arg half expression to round
+        /// \return nearest integer using default rounding mode
 //		template<typename T> typename enable<half,T>::type rint(T arg) { return functions::rint(arg); }
-		inline half rint(half arg) { return functions::rint(arg); }
-		inline half rint(expr arg) { return functions::rint(arg); }
+        inline half rint(half arg) { return functions::rint(arg); }
+        inline half rint(expr arg) { return functions::rint(arg); }
 
-		/// Nearest integer using half's internal rounding mode.
-		/// \param arg half expression to round
-		/// \return nearest integer using default rounding mode
+        /// Nearest integer using half's internal rounding mode.
+        /// \param arg half expression to round
+        /// \return nearest integer using default rounding mode
 //		template<typename T> typename enable<long,T>::type lrint(T arg) { return functions::lrint(arg); }
-		inline long lrint(half arg) { return functions::lrint(arg); }
-		inline long lrint(expr arg) { return functions::lrint(arg); }
-	#if HALF_ENABLE_CPP11_LONG_LONG
-		/// Nearest integer.
-		/// \param arg half to round
-		/// \return nearest integer, rounded away from zero in half-way cases
+        inline long lrint(half arg) { return functions::lrint(arg); }
+        inline long lrint(expr arg) { return functions::lrint(arg); }
+    #if HALF_ENABLE_CPP11_LONG_LONG
+        /// Nearest integer.
+        /// \param arg half to round
+        /// \return nearest integer, rounded away from zero in half-way cases
 //		template<typename T> typename enable<long long,T>::type llround(T arg) { return functions::llround(arg); }
-		inline long long llround(half arg) { return functions::llround(arg); }
-		inline long long llround(expr arg) { return functions::llround(arg); }
+        inline long long llround(half arg) { return functions::llround(arg); }
+        inline long long llround(expr arg) { return functions::llround(arg); }
 
-		/// Nearest integer using half's internal rounding mode.
-		/// \param arg half expression to round
-		/// \return nearest integer using default rounding mode
+        /// Nearest integer using half's internal rounding mode.
+        /// \param arg half expression to round
+        /// \return nearest integer using default rounding mode
 //		template<typename T> typename enable<long long,T>::type llrint(T arg) { return functions::llrint(arg); }
-		inline long long llrint(half arg) { return functions::llrint(arg); }
-		inline long long llrint(expr arg) { return functions::llrint(arg); }
-	#endif
-
-		/// \}
-		/// \name Floating point manipulation
-		/// \{
-
-		/// Decompress floating point number.
-		/// \param arg number to decompress
-		/// \param exp address to store exponent at
-		/// \return significant in range [0.5, 1)
+        inline long long llrint(half arg) { return functions::llrint(arg); }
+        inline long long llrint(expr arg) { return functions::llrint(arg); }
+    #endif
+
+        /// \}
+        /// \name Floating point manipulation
+        /// \{
+
+        /// Decompress floating point number.
+        /// \param arg number to decompress
+        /// \param exp address to store exponent at
+        /// \return significant in range [0.5, 1)
 //		template<typename T> typename enable<half,T>::type frexp(T arg, int *exp) { return functions::frexp(arg, exp); }
-		inline half frexp(half arg, int *exp) { return functions::frexp(arg, exp); }
-		inline half frexp(expr arg, int *exp) { return functions::frexp(arg, exp); }
+        inline half frexp(half arg, int *exp) { return functions::frexp(arg, exp); }
+        inline half frexp(expr arg, int *exp) { return functions::frexp(arg, exp); }
 
-		/// Multiply by power of two.
-		/// \param arg number to modify
-		/// \param exp power of two to multiply with
-		/// \return \a arg multplied by 2 raised to \a exp
+        /// Multiply by power of two.
+        /// \param arg number to modify
+        /// \param exp power of two to multiply with
+        /// \return \a arg multplied by 2 raised to \a exp
 //		template<typename T> typename enable<half,T>::type ldexp(T arg, int exp) { return functions::scalbln(arg, exp); }
-		inline half ldexp(half arg, int exp) { return functions::scalbln(arg, exp); }
-		inline half ldexp(expr arg, int exp) { return functions::scalbln(arg, exp); }
+        inline half ldexp(half arg, int exp) { return functions::scalbln(arg, exp); }
+        inline half ldexp(expr arg, int exp) { return functions::scalbln(arg, exp); }
 
-		/// Extract integer and fractional parts.
-		/// \param arg number to decompress
-		/// \param iptr address to store integer part at
-		/// \return fractional part
+        /// Extract integer and fractional parts.
+        /// \param arg number to decompress
+        /// \param iptr address to store integer part at
+        /// \return fractional part
 //		template<typename T> typename enable<half,T>::type modf(T arg, half *iptr) { return functions::modf(arg, iptr); }
-		inline half modf(half arg, half *iptr) { return functions::modf(arg, iptr); }
-		inline half modf(expr arg, half *iptr) { return functions::modf(arg, iptr); }
+        inline half modf(half arg, half *iptr) { return functions::modf(arg, iptr); }
+        inline half modf(expr arg, half *iptr) { return functions::modf(arg, iptr); }
 
-		/// Multiply by power of two.
-		/// \param arg number to modify
-		/// \param exp power of two to multiply with
-		/// \return \a arg multplied by 2 raised to \a exp
+        /// Multiply by power of two.
+        /// \param arg number to modify
+        /// \param exp power of two to multiply with
+        /// \return \a arg multplied by 2 raised to \a exp
 //		template<typename T> typename enable<half,T>::type scalbn(T arg, int exp) { return functions::scalbln(arg, exp); }
-		inline half scalbn(half arg, int exp) { return functions::scalbln(arg, exp); }
-		inline half scalbn(expr arg, int exp) { return functions::scalbln(arg, exp); }
+        inline half scalbn(half arg, int exp) { return functions::scalbln(arg, exp); }
+        inline half scalbn(expr arg, int exp) { return functions::scalbln(arg, exp); }
 
-		/// Multiply by power of two.
-		/// \param arg number to modify
-		/// \param exp power of two to multiply with
-		/// \return \a arg multplied by 2 raised to \a exp	
+        /// Multiply by power of two.
+        /// \param arg number to modify
+        /// \param exp power of two to multiply with
+        /// \return \a arg multplied by 2 raised to \a exp	
 //		template<typename T> typename enable<half,T>::type scalbln(T arg, long exp) { return functions::scalbln(arg, exp); }
-		inline half scalbln(half arg, long exp) { return functions::scalbln(arg, exp); }
-		inline half scalbln(expr arg, long exp) { return functions::scalbln(arg, exp); }
-
-		/// Extract exponent.
-		/// \param arg number to query
-		/// \return floating point exponent
-		/// \retval FP_ILOGB0 for zero
-		/// \retval FP_ILOGBNAN for NaN
-		/// \retval MAX_INT for infinity
+        inline half scalbln(half arg, long exp) { return functions::scalbln(arg, exp); }
+        inline half scalbln(expr arg, long exp) { return functions::scalbln(arg, exp); }
+
+        /// Extract exponent.
+        /// \param arg number to query
+        /// \return floating point exponent
+        /// \retval FP_ILOGB0 for zero
+        /// \retval FP_ILOGBNAN for NaN
+        /// \retval MAX_INT for infinity
 //		template<typename T> typename enable<int,T>::type ilogb(T arg) { return functions::ilogb(arg); }
-		inline int ilogb(half arg) { return functions::ilogb(arg); }
-		inline int ilogb(expr arg) { return functions::ilogb(arg); }
+        inline int ilogb(half arg) { return functions::ilogb(arg); }
+        inline int ilogb(expr arg) { return functions::ilogb(arg); }
 
-		/// Extract exponent.
-		/// \param arg number to query
-		/// \return floating point exponent
+        /// Extract exponent.
+        /// \param arg number to query
+        /// \return floating point exponent
 //		template<typename T> typename enable<half,T>::type logb(T arg) { return functions::logb(arg); }
-		inline half logb(half arg) { return functions::logb(arg); }
-		inline half logb(expr arg) { return functions::logb(arg); }
+        inline half logb(half arg) { return functions::logb(arg); }
+        inline half logb(expr arg) { return functions::logb(arg); }
 
-		/// Next representable value.
-		/// \param from value to compute next representable value for
-		/// \param to direction towards which to compute next value
-		/// \return next representable value after \a from in direction towards \a to
+        /// Next representable value.
+        /// \param from value to compute next representable value for
+        /// \param to direction towards which to compute next value
+        /// \return next representable value after \a from in direction towards \a to
 //		template<typename T,typename U> typename enable<half,T,U>::type nextafter(T from, U to) { return functions::nextafter(from, to); }
-		inline half nextafter(half from, half to) { return functions::nextafter(from, to); }
-		inline half nextafter(half from, expr to) { return functions::nextafter(from, to); }
-		inline half nextafter(expr from, half to) { return functions::nextafter(from, to); }
-		inline half nextafter(expr from, expr to) { return functions::nextafter(from, to); }
-
-		/// Next representable value.
-		/// \param from value to compute next representable value for
-		/// \param to direction towards which to compute next value
-		/// \return next representable value after \a from in direction towards \a to
+        inline half nextafter(half from, half to) { return functions::nextafter(from, to); }
+        inline half nextafter(half from, expr to) { return functions::nextafter(from, to); }
+        inline half nextafter(expr from, half to) { return functions::nextafter(from, to); }
+        inline half nextafter(expr from, expr to) { return functions::nextafter(from, to); }
+
+        /// Next representable value.
+        /// \param from value to compute next representable value for
+        /// \param to direction towards which to compute next value
+        /// \return next representable value after \a from in direction towards \a to
 //		template<typename T> typename enable<half,T>::type nexttoward(T from, long double to) { return functions::nexttoward(from, to); }
-		inline half nexttoward(half from, long double to) { return functions::nexttoward(from, to); }
-		inline half nexttoward(expr from, long double to) { return functions::nexttoward(from, to); }
+        inline half nexttoward(half from, long double to) { return functions::nexttoward(from, to); }
+        inline half nexttoward(expr from, long double to) { return functions::nexttoward(from, to); }
 
-		/// Take sign.
-		/// \param x value to change sign for
-		/// \param y value to take sign from
-		/// \return value equal to \a x in magnitude and to \a y in sign
+        /// Take sign.
+        /// \param x value to change sign for
+        /// \param y value to take sign from
+        /// \return value equal to \a x in magnitude and to \a y in sign
 //		template<typename T,typename U> typename enable<half,T,U>::type copysign(T x, U y) { return functions::copysign(x, y); }
-		inline half copysign(half x, half y) { return functions::copysign(x, y); }
-		inline half copysign(half x, expr y) { return functions::copysign(x, y); }
-		inline half copysign(expr x, half y) { return functions::copysign(x, y); }
-		inline half copysign(expr x, expr y) { return functions::copysign(x, y); }
-
-		/// \}
-		/// \name Floating point classification
-		/// \{
-
-
-		/// Classify floating point value.
-		/// \param arg number to classify
-		/// \retval FP_ZERO for positive and negative zero
-		/// \retval FP_SUBNORMAL for subnormal numbers
-		/// \retval FP_INFINITY for positive and negative infinity
-		/// \retval FP_NAN for NaNs
-		/// \retval FP_NORMAL for all other (normal) values
+        inline half copysign(half x, half y) { return functions::copysign(x, y); }
+        inline half copysign(half x, expr y) { return functions::copysign(x, y); }
+        inline half copysign(expr x, half y) { return functions::copysign(x, y); }
+        inline half copysign(expr x, expr y) { return functions::copysign(x, y); }
+
+        /// \}
+        /// \name Floating point classification
+        /// \{
+
+
+        /// Classify floating point value.
+        /// \param arg number to classify
+        /// \retval FP_ZERO for positive and negative zero
+        /// \retval FP_SUBNORMAL for subnormal numbers
+        /// \retval FP_INFINITY for positive and negative infinity
+        /// \retval FP_NAN for NaNs
+        /// \retval FP_NORMAL for all other (normal) values
 //		template<typename T> typename enable<int,T>::type fpclassify(T arg) { return functions::fpclassify(arg); }
-		inline int fpclassify(half arg) { return functions::fpclassify(arg); }
-		inline int fpclassify(expr arg) { return functions::fpclassify(arg); }
+        inline int fpclassify(half arg) { return functions::fpclassify(arg); }
+        inline int fpclassify(expr arg) { return functions::fpclassify(arg); }
 
-		/// Check if finite number.
-		/// \param arg number to check
-		/// \retval true if neither infinity nor NaN
-		/// \retval false else
+        /// Check if finite number.
+        /// \param arg number to check
+        /// \retval true if neither infinity nor NaN
+        /// \retval false else
 //		template<typename T> typename enable<bool,T>::type isfinite(T arg) { return functions::isfinite(arg); }
-		inline bool isfinite(half arg) { return functions::isfinite(arg); }
-		inline bool isfinite(expr arg) { return functions::isfinite(arg); }
+        inline bool isfinite(half arg) { return functions::isfinite(arg); }
+        inline bool isfinite(expr arg) { return functions::isfinite(arg); }
 
-		/// Check for infinity.
-		/// \param arg number to check
-		/// \retval true for positive or negative infinity
-		/// \retval false else
+        /// Check for infinity.
+        /// \param arg number to check
+        /// \retval true for positive or negative infinity
+        /// \retval false else
 //		template<typename T> typename enable<bool,T>::type isinf(T arg) { return functions::isinf(arg); }
-		inline bool isinf(half arg) { return functions::isinf(arg); }
-		inline bool isinf(expr arg) { return functions::isinf(arg); }
+        inline bool isinf(half arg) { return functions::isinf(arg); }
+        inline bool isinf(expr arg) { return functions::isinf(arg); }
 
-		/// Check for NaN.
-		/// \param arg number to check
-		/// \retval true for NaNs
-		/// \retval false else
+        /// Check for NaN.
+        /// \param arg number to check
+        /// \retval true for NaNs
+        /// \retval false else
 //		template<typename T> typename enable<bool,T>::type isnan(T arg) { return functions::isnan(arg); }
-		inline bool isnan(half arg) { return functions::isnan(arg); }
-		inline bool isnan(expr arg) { return functions::isnan(arg); }
+        inline bool isnan(half arg) { return functions::isnan(arg); }
+        inline bool isnan(expr arg) { return functions::isnan(arg); }
 
-		/// Check if normal number.
-		/// \param arg number to check
-		/// \retval true if normal number
-		/// \retval false if either subnormal, zero, infinity or NaN
+        /// Check if normal number.
+        /// \param arg number to check
+        /// \retval true if normal number
+        /// \retval false if either subnormal, zero, infinity or NaN
 //		template<typename T> typename enable<bool,T>::type isnormal(T arg) { return functions::isnormal(arg); }
-		inline bool isnormal(half arg) { return functions::isnormal(arg); }
-		inline bool isnormal(expr arg) { return functions::isnormal(arg); }
+        inline bool isnormal(half arg) { return functions::isnormal(arg); }
+        inline bool isnormal(expr arg) { return functions::isnormal(arg); }
 
-		/// Check sign.
-		/// \param arg number to check
-		/// \retval true for negative number
-		/// \retval false for positive number
+        /// Check sign.
+        /// \param arg number to check
+        /// \retval true for negative number
+        /// \retval false for positive number
 //		template<typename T> typename enable<bool,T>::type signbit(T arg) { return functions::signbit(arg); }
-		inline bool signbit(half arg) { return functions::signbit(arg); }
-		inline bool signbit(expr arg) { return functions::signbit(arg); }
-
-		/// \}
-		/// \name Comparison
-		/// \{
-
-		/// Comparison for greater than.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if \a x greater than \a y
-		/// \retval false else
+        inline bool signbit(half arg) { return functions::signbit(arg); }
+        inline bool signbit(expr arg) { return functions::signbit(arg); }
+
+        /// \}
+        /// \name Comparison
+        /// \{
+
+        /// Comparison for greater than.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if \a x greater than \a y
+        /// \retval false else
 //		template<typename T,typename U> typename enable<bool,T,U>::type isgreater(T x, U y) { return functions::isgreater(x, y); }
-		inline bool isgreater(half x, half y) { return functions::isgreater(x, y); }
-		inline bool isgreater(half x, expr y) { return functions::isgreater(x, y); }
-		inline bool isgreater(expr x, half y) { return functions::isgreater(x, y); }
-		inline bool isgreater(expr x, expr y) { return functions::isgreater(x, y); }
-
-		/// Comparison for greater equal.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if \a x greater equal \a y
-		/// \retval false else
+        inline bool isgreater(half x, half y) { return functions::isgreater(x, y); }
+        inline bool isgreater(half x, expr y) { return functions::isgreater(x, y); }
+        inline bool isgreater(expr x, half y) { return functions::isgreater(x, y); }
+        inline bool isgreater(expr x, expr y) { return functions::isgreater(x, y); }
+
+        /// Comparison for greater equal.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if \a x greater equal \a y
+        /// \retval false else
 //		template<typename T,typename U> typename enable<bool,T,U>::type isgreaterequal(T x, U y) { return functions::isgreaterequal(x, y); }
-		inline bool isgreaterequal(half x, half y) { return functions::isgreaterequal(x, y); }
-		inline bool isgreaterequal(half x, expr y) { return functions::isgreaterequal(x, y); }
-		inline bool isgreaterequal(expr x, half y) { return functions::isgreaterequal(x, y); }
-		inline bool isgreaterequal(expr x, expr y) { return functions::isgreaterequal(x, y); }
-
-		/// Comparison for less than.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if \a x less than \a y
-		/// \retval false else
+        inline bool isgreaterequal(half x, half y) { return functions::isgreaterequal(x, y); }
+        inline bool isgreaterequal(half x, expr y) { return functions::isgreaterequal(x, y); }
+        inline bool isgreaterequal(expr x, half y) { return functions::isgreaterequal(x, y); }
+        inline bool isgreaterequal(expr x, expr y) { return functions::isgreaterequal(x, y); }
+
+        /// Comparison for less than.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if \a x less than \a y
+        /// \retval false else
 //		template<typename T,typename U> typename enable<bool,T,U>::type isless(T x, U y) { return functions::isless(x, y); }
-		inline bool isless(half x, half y) { return functions::isless(x, y); }
-		inline bool isless(half x, expr y) { return functions::isless(x, y); }
-		inline bool isless(expr x, half y) { return functions::isless(x, y); }
-		inline bool isless(expr x, expr y) { return functions::isless(x, y); }
-
-		/// Comparison for less equal.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if \a x less equal \a y
-		/// \retval false else
+        inline bool isless(half x, half y) { return functions::isless(x, y); }
+        inline bool isless(half x, expr y) { return functions::isless(x, y); }
+        inline bool isless(expr x, half y) { return functions::isless(x, y); }
+        inline bool isless(expr x, expr y) { return functions::isless(x, y); }
+
+        /// Comparison for less equal.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if \a x less equal \a y
+        /// \retval false else
 //		template<typename T,typename U> typename enable<bool,T,U>::type islessequal(T x, U y) { return functions::islessequal(x, y); }
-		inline bool islessequal(half x, half y) { return functions::islessequal(x, y); }
-		inline bool islessequal(half x, expr y) { return functions::islessequal(x, y); }
-		inline bool islessequal(expr x, half y) { return functions::islessequal(x, y); }
-		inline bool islessequal(expr x, expr y) { return functions::islessequal(x, y); }
-
-		/// Comarison for less or greater.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if either less or greater
-		/// \retval false else
+        inline bool islessequal(half x, half y) { return functions::islessequal(x, y); }
+        inline bool islessequal(half x, expr y) { return functions::islessequal(x, y); }
+        inline bool islessequal(expr x, half y) { return functions::islessequal(x, y); }
+        inline bool islessequal(expr x, expr y) { return functions::islessequal(x, y); }
+
+        /// Comarison for less or greater.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if either less or greater
+        /// \retval false else
 //		template<typename T,typename U> typename enable<bool,T,U>::type islessgreater(T x, U y) { return functions::islessgreater(x, y); }
-		inline bool islessgreater(half x, half y) { return functions::islessgreater(x, y); }
-		inline bool islessgreater(half x, expr y) { return functions::islessgreater(x, y); }
-		inline bool islessgreater(expr x, half y) { return functions::islessgreater(x, y); }
-		inline bool islessgreater(expr x, expr y) { return functions::islessgreater(x, y); }
-
-		/// Check if unordered.
-		/// \param x first operand
-		/// \param y second operand
-		/// \retval true if unordered (one or two NaN operands)
-		/// \retval false else
+        inline bool islessgreater(half x, half y) { return functions::islessgreater(x, y); }
+        inline bool islessgreater(half x, expr y) { return functions::islessgreater(x, y); }
+        inline bool islessgreater(expr x, half y) { return functions::islessgreater(x, y); }
+        inline bool islessgreater(expr x, expr y) { return functions::islessgreater(x, y); }
+
+        /// Check if unordered.
+        /// \param x first operand
+        /// \param y second operand
+        /// \retval true if unordered (one or two NaN operands)
+        /// \retval false else
 //		template<typename T,typename U> typename enable<bool,T,U>::type isunordered(T x, U y) { return functions::isunordered(x, y); }
-		inline bool isunordered(half x, half y) { return functions::isunordered(x, y); }
-		inline bool isunordered(half x, expr y) { return functions::isunordered(x, y); }
-		inline bool isunordered(expr x, half y) { return functions::isunordered(x, y); }
-		inline bool isunordered(expr x, expr y) { return functions::isunordered(x, y); }
-
-		/// \name Casting
-		/// \{
-
-		/// Cast to or from half-precision floating point number.
-		/// This casts between [half](\ref halffloat::half) and any built-in arithmetic type. The values are converted 
-		/// directly using the given rounding mode, without any roundtrip over `float` that a `static_cast` would otherwise do. 
-		/// It uses the default rounding mode.
-		///
-		/// Using this cast with neither of the two types being a [half](\ref halffloat::half) or with any of the two types 
-		/// not being a built-in arithmetic type (apart from [half](\ref halffloat::half), of course) results in a compiler 
-		/// error and casting between [half](\ref halffloat::half)s is just a no-op.
-		/// \tparam T destination type (half or built-in arithmetic type)
-		/// \tparam U source type (half or built-in arithmetic type)
-		/// \param arg value to cast
-		/// \return \a arg converted to destination type
-		template<typename T,typename U> T half_cast(U arg) { return half_caster<T,U>::cast(arg); }
-
-		/// Cast to or from half-precision floating point number.
-		/// This casts between [half](\ref halffloat::half) and any built-in arithmetic type. The values are converted 
-		/// directly using the given rounding mode, without any roundtrip over `float` that a `static_cast` would otherwise do.
-		///
-		/// Using this cast with neither of the two types being a [half](\ref halffloat::half) or with any of the two types 
-		/// not being a built-in arithmetic type (apart from [half](\ref halffloat::half), of course) results in a compiler 
-		/// error and casting between [half](\ref halffloat::half)s is just a no-op.
-		/// \tparam T destination type (half or built-in arithmetic type)
-		/// \tparam R rounding mode to use.
-		/// \tparam U source type (half or built-in arithmetic type)
-		/// \param arg value to cast
-		/// \return \a arg converted to destination type
-		template<typename T,std::float_round_style R,typename U> T half_cast(U arg) { return half_caster<T,U,R>::cast(arg); }
-		/// \}
-	}
-
-	using detail::operator==;
-	using detail::operator!=;
-	using detail::operator<;
-	using detail::operator>;
-	using detail::operator<=;
-	using detail::operator>=;
-	using detail::operator+;
-	using detail::operator-;
-	using detail::operator*;
-	using detail::operator/;
-	using detail::operator<<;
-	using detail::operator>>;
-
-	using detail::abs;
-	using detail::fabs;
-	using detail::fmod;
-	using detail::remainder;
-	using detail::remquo;
-	using detail::fma;
-	using detail::fmax;
-	using detail::fmin;
-	using detail::fdim;
-	using detail::nanh;
-	using detail::exp;
-	using detail::expm1;
-	using detail::exp2;
-	using detail::log;
-	using detail::log10;
-	using detail::log1p;
-	using detail::log2;
-	using detail::sqrt;
-	using detail::cbrt;
-	using detail::hypot;
-	using detail::pow;
-	using detail::sin;
-	using detail::cos;
-	using detail::tan;
-	using detail::asin;
-	using detail::acos;
-	using detail::atan;
-	using detail::atan2;
-	using detail::sinh;
-	using detail::cosh;
-	using detail::tanh;
-	using detail::asinh;
-	using detail::acosh;
-	using detail::atanh;
-	using detail::erf;
-	using detail::erfc;
-	using detail::lgamma;
-	using detail::tgamma;
-	using detail::ceil;
-	using detail::floor;
-	using detail::trunc;
-	using detail::round;
-	using detail::lround;
-	using detail::nearbyint;
-	using detail::rint;
-	using detail::lrint;
+        inline bool isunordered(half x, half y) { return functions::isunordered(x, y); }
+        inline bool isunordered(half x, expr y) { return functions::isunordered(x, y); }
+        inline bool isunordered(expr x, half y) { return functions::isunordered(x, y); }
+        inline bool isunordered(expr x, expr y) { return functions::isunordered(x, y); }
+
+        /// \name Casting
+        /// \{
+
+        /// Cast to or from half-precision floating point number.
+        /// This casts between [half](\ref halffloat::half) and any built-in arithmetic type. The values are converted 
+        /// directly using the given rounding mode, without any roundtrip over `float` that a `static_cast` would otherwise do. 
+        /// It uses the default rounding mode.
+        ///
+        /// Using this cast with neither of the two types being a [half](\ref halffloat::half) or with any of the two types 
+        /// not being a built-in arithmetic type (apart from [half](\ref halffloat::half), of course) results in a compiler 
+        /// error and casting between [half](\ref halffloat::half)s is just a no-op.
+        /// \tparam T destination type (half or built-in arithmetic type)
+        /// \tparam U source type (half or built-in arithmetic type)
+        /// \param arg value to cast
+        /// \return \a arg converted to destination type
+        template<typename T,typename U> T half_cast(U arg) { return half_caster<T,U>::cast(arg); }
+
+        /// Cast to or from half-precision floating point number.
+        /// This casts between [half](\ref halffloat::half) and any built-in arithmetic type. The values are converted 
+        /// directly using the given rounding mode, without any roundtrip over `float` that a `static_cast` would otherwise do.
+        ///
+        /// Using this cast with neither of the two types being a [half](\ref halffloat::half) or with any of the two types 
+        /// not being a built-in arithmetic type (apart from [half](\ref halffloat::half), of course) results in a compiler 
+        /// error and casting between [half](\ref halffloat::half)s is just a no-op.
+        /// \tparam T destination type (half or built-in arithmetic type)
+        /// \tparam R rounding mode to use.
+        /// \tparam U source type (half or built-in arithmetic type)
+        /// \param arg value to cast
+        /// \return \a arg converted to destination type
+        template<typename T,std::float_round_style R,typename U> T half_cast(U arg) { return half_caster<T,U,R>::cast(arg); }
+        /// \}
+    }
+
+    using detail::operator==;
+    using detail::operator!=;
+    using detail::operator<;
+    using detail::operator>;
+    using detail::operator<=;
+    using detail::operator>=;
+    using detail::operator+;
+    using detail::operator-;
+    using detail::operator*;
+    using detail::operator/;
+    using detail::operator<<;
+    using detail::operator>>;
+
+    using detail::abs;
+    using detail::fabs;
+    using detail::fmod;
+    using detail::remainder;
+    using detail::remquo;
+    using detail::fma;
+    using detail::fmax;
+    using detail::fmin;
+    using detail::fdim;
+    using detail::nanh;
+    using detail::exp;
+    using detail::expm1;
+    using detail::exp2;
+    using detail::log;
+    using detail::log10;
+    using detail::log1p;
+    using detail::log2;
+    using detail::sqrt;
+    using detail::cbrt;
+    using detail::hypot;
+    using detail::pow;
+    using detail::sin;
+    using detail::cos;
+    using detail::tan;
+    using detail::asin;
+    using detail::acos;
+    using detail::atan;
+    using detail::atan2;
+    using detail::sinh;
+    using detail::cosh;
+    using detail::tanh;
+    using detail::asinh;
+    using detail::acosh;
+    using detail::atanh;
+    using detail::erf;
+    using detail::erfc;
+    using detail::lgamma;
+    using detail::tgamma;
+    using detail::ceil;
+    using detail::floor;
+    using detail::trunc;
+    using detail::round;
+    using detail::lround;
+    using detail::nearbyint;
+    using detail::rint;
+    using detail::lrint;
 #if HALF_ENABLE_CPP11_LONG_LONG
-	using detail::llround;
-	using detail::llrint;
+    using detail::llround;
+    using detail::llrint;
 #endif
-	using detail::frexp;
-	using detail::ldexp;
-	using detail::modf;
-	using detail::scalbn;
-	using detail::scalbln;
-	using detail::ilogb;
-	using detail::logb;
-	using detail::nextafter;
-	using detail::nexttoward;
-	using detail::copysign;
-	using detail::fpclassify;
-	using detail::isfinite;
-	using detail::isinf;
-	using detail::isnan;
-	using detail::isnormal;
-	using detail::signbit;
-	using detail::isgreater;
-	using detail::isgreaterequal;
-	using detail::isless;
-	using detail::islessequal;
-	using detail::islessgreater;
-	using detail::isunordered;
-
-	using detail::half_cast;
+    using detail::frexp;
+    using detail::ldexp;
+    using detail::modf;
+    using detail::scalbn;
+    using detail::scalbln;
+    using detail::ilogb;
+    using detail::logb;
+    using detail::nextafter;
+    using detail::nexttoward;
+    using detail::copysign;
+    using detail::fpclassify;
+    using detail::isfinite;
+    using detail::isinf;
+    using detail::isnan;
+    using detail::isnormal;
+    using detail::signbit;
+    using detail::isgreater;
+    using detail::isgreaterequal;
+    using detail::isless;
+    using detail::islessequal;
+    using detail::islessgreater;
+    using detail::isunordered;
+
+    using detail::half_cast;
 }
 
 
 /// Extensions to the C++ standard library.
 namespace std
 {
-	/// Numeric limits for half-precision floats.
-	/// Because of the underlying single-precision implementation of many operations, it inherits some properties from 
-	/// `std::numeric_limits<float>`.
-	template<> class numeric_limits<halffloat::half> : public numeric_limits<float>
-	{
-	public:
-		/// Supports signed values.
-		static HALF_CONSTEXPR_CONST bool is_signed = true;
+    /// Numeric limits for half-precision floats.
+    /// Because of the underlying single-precision implementation of many operations, it inherits some properties from 
+    /// `std::numeric_limits<float>`.
+    template<> class numeric_limits<halffloat::half> : public numeric_limits<float>
+    {
+    public:
+        /// Supports signed values.
+        static HALF_CONSTEXPR_CONST bool is_signed = true;
 
-		/// Is not exact.
-		static HALF_CONSTEXPR_CONST bool is_exact = false;
+        /// Is not exact.
+        static HALF_CONSTEXPR_CONST bool is_exact = false;
 
-		/// Doesn't provide modulo arithmetic.
-		static HALF_CONSTEXPR_CONST bool is_modulo = false;
+        /// Doesn't provide modulo arithmetic.
+        static HALF_CONSTEXPR_CONST bool is_modulo = false;
 
-		/// IEEE conformant.
-		static HALF_CONSTEXPR_CONST bool is_iec559 = true;
+        /// IEEE conformant.
+        static HALF_CONSTEXPR_CONST bool is_iec559 = true;
 
-		/// Supports infinity.
-		static HALF_CONSTEXPR_CONST bool has_infinity = true;
+        /// Supports infinity.
+        static HALF_CONSTEXPR_CONST bool has_infinity = true;
 
-		/// Supports quiet NaNs.
-		static HALF_CONSTEXPR_CONST bool has_quiet_NaN = true;
+        /// Supports quiet NaNs.
+        static HALF_CONSTEXPR_CONST bool has_quiet_NaN = true;
 
-		/// Supports subnormal values.
-		static HALF_CONSTEXPR_CONST float_denorm_style has_denorm = denorm_present;
+        /// Supports subnormal values.
+        static HALF_CONSTEXPR_CONST float_denorm_style has_denorm = denorm_present;
 
-		/// Rounding mode.
-		/// Due to the mix of internal single-precision computations (using the rounding mode of the underlying 
-		/// single-precision implementation) with the rounding mode of the single-to-half conversions, the actual rounding 
-		/// mode might be `std::round_indeterminate` if the default half-precision rounding mode doesn't match the 
-		/// single-precision rounding mode.
-		static HALF_CONSTEXPR_CONST float_round_style round_style = (std::numeric_limits<float>::round_style==
-			halffloat::half::round_style) ? halffloat::half::round_style : round_indeterminate;
+        /// Rounding mode.
+        /// Due to the mix of internal single-precision computations (using the rounding mode of the underlying 
+        /// single-precision implementation) with the rounding mode of the single-to-half conversions, the actual rounding 
+        /// mode might be `std::round_indeterminate` if the default half-precision rounding mode doesn't match the 
+        /// single-precision rounding mode.
+        static HALF_CONSTEXPR_CONST float_round_style round_style = (std::numeric_limits<float>::round_style==
+            halffloat::half::round_style) ? halffloat::half::round_style : round_indeterminate;
 
-		/// Significant digits.
-		static HALF_CONSTEXPR_CONST int digits = 11;
+        /// Significant digits.
+        static HALF_CONSTEXPR_CONST int digits = 11;
 
-		/// Significant decimal digits.
-		static HALF_CONSTEXPR_CONST int digits10 = 3;
+        /// Significant decimal digits.
+        static HALF_CONSTEXPR_CONST int digits10 = 3;
 
-		/// Required decimal digits to represent all possible values.
-		static HALF_CONSTEXPR_CONST int max_digits10 = 5;
+        /// Required decimal digits to represent all possible values.
+        static HALF_CONSTEXPR_CONST int max_digits10 = 5;
 
-		/// Number base.
-		static HALF_CONSTEXPR_CONST int radix = 2;
+        /// Number base.
+        static HALF_CONSTEXPR_CONST int radix = 2;
 
-		/// One more than smallest exponent.
-		static HALF_CONSTEXPR_CONST int min_exponent = -13;
+        /// One more than smallest exponent.
+        static HALF_CONSTEXPR_CONST int min_exponent = -13;
 
-		/// Smallest normalized representable power of 10.
-		static HALF_CONSTEXPR_CONST int min_exponent10 = -4;
+        /// Smallest normalized representable power of 10.
+        static HALF_CONSTEXPR_CONST int min_exponent10 = -4;
 
-		/// One more than largest exponent
-		static HALF_CONSTEXPR_CONST int max_exponent = 16;
+        /// One more than largest exponent
+        static HALF_CONSTEXPR_CONST int max_exponent = 16;
 
-		/// Largest finitely representable power of 10.
-		static HALF_CONSTEXPR_CONST int max_exponent10 = 4;
+        /// Largest finitely representable power of 10.
+        static HALF_CONSTEXPR_CONST int max_exponent10 = 4;
 
-		/// Smallest positive normal value.
-		static HALF_CONSTEXPR halffloat::half min() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x0400); }
+        /// Smallest positive normal value.
+        static HALF_CONSTEXPR halffloat::half min() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x0400); }
 
-		/// Smallest finite value.
-		static HALF_CONSTEXPR halffloat::half lowest() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0xFBFF); }
+        /// Smallest finite value.
+        static HALF_CONSTEXPR halffloat::half lowest() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0xFBFF); }
 
-		/// Largest finite value.
-		static HALF_CONSTEXPR halffloat::half max() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x7BFF); }
+        /// Largest finite value.
+        static HALF_CONSTEXPR halffloat::half max() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x7BFF); }
 
-		/// Difference between one and next representable value.
-		static HALF_CONSTEXPR halffloat::half epsilon() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x1400); }
+        /// Difference between one and next representable value.
+        static HALF_CONSTEXPR halffloat::half epsilon() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x1400); }
 
-		/// Maximum rounding error.
-		static HALF_CONSTEXPR halffloat::half round_error() HALF_NOTHROW
-			{ return halffloat::half(halffloat::detail::binary, (round_style==std::round_to_nearest) ? 0x3800 : 0x3C00); }
+        /// Maximum rounding error.
+        static HALF_CONSTEXPR halffloat::half round_error() HALF_NOTHROW
+            { return halffloat::half(halffloat::detail::binary, (round_style==std::round_to_nearest) ? 0x3800 : 0x3C00); }
 
-		/// Positive infinity.
-		static HALF_CONSTEXPR halffloat::half infinity() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x7C00); }
+        /// Positive infinity.
+        static HALF_CONSTEXPR halffloat::half infinity() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x7C00); }
 
-		/// Quiet NaN.
-		static HALF_CONSTEXPR halffloat::half quiet_NaN() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x7FFF); }
+        /// Quiet NaN.
+        static HALF_CONSTEXPR halffloat::half quiet_NaN() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x7FFF); }
 
-		/// Signalling NaN.
-		static HALF_CONSTEXPR halffloat::half signaling_NaN() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x7DFF); }
+        /// Signalling NaN.
+        static HALF_CONSTEXPR halffloat::half signaling_NaN() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x7DFF); }
 
-		/// Smallest positive subnormal value.
-		static HALF_CONSTEXPR halffloat::half denorm_min() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x0001); }
-	};
+        /// Smallest positive subnormal value.
+        static HALF_CONSTEXPR halffloat::half denorm_min() HALF_NOTHROW { return halffloat::half(halffloat::detail::binary, 0x0001); }
+    };
 
 #if HALF_ENABLE_CPP11_HASH
-	/// Hash function for half-precision floats.
-	/// This is only defined if C++11 `std::hash` is supported and enabled.
-	template<> struct hash<halffloat::half> //: unary_function<halffloat::half,size_t>
-	{
-		/// Type of function argument.
-		typedef halffloat::half argument_type;
-
-		/// Function return type.
-		typedef size_t result_type;
-
-		/// Compute hash function.
-		/// \param arg half to hash
-		/// \return hash value
-		result_type operator()(argument_type arg) const
-			{ return hash<halffloat::detail::uint16>()(static_cast<unsigned>(arg.data_)&-(arg.data_!=0x8000)); }
-	};
+    /// Hash function for half-precision floats.
+    /// This is only defined if C++11 `std::hash` is supported and enabled.
+    template<> struct hash<halffloat::half> //: unary_function<halffloat::half,size_t>
+    {
+        /// Type of function argument.
+        typedef halffloat::half argument_type;
+
+        /// Function return type.
+        typedef size_t result_type;
+
+        /// Compute hash function.
+        /// \param arg half to hash
+        /// \return hash value
+        result_type operator()(argument_type arg) const
+            { return hash<halffloat::detail::uint16>()(static_cast<unsigned>(arg.data_)&-(arg.data_!=0x8000)); }
+    };
 #endif
 }
 
@@ -3061,8 +3061,8 @@ namespace std
 #undef HALF_NOEXCEPT
 #undef HALF_NOTHROW
 #ifdef HALF_POP_WARNINGS
-	#pragma warning(pop)
-	#undef HALF_POP_WARNINGS
+    #pragma warning(pop)
+    #undef HALF_POP_WARNINGS
 #endif
 
 #endif
\ No newline at end of file
diff --git a/Source/Base/Base/Memory/FileWriter.h b/Source/Base/Base/Memory/FileWriter.h
index e612660c..30ce2dc6 100644
--- a/Source/Base/Base/Memory/FileWriter.h
+++ b/Source/Base/Base/Memory/FileWriter.h
@@ -10,27 +10,27 @@ class Bytebuffer;
 class FileWriter
 {
 public:
-	FileWriter(std::filesystem::path path, std::shared_ptr<Bytebuffer>& buffer) : _path(path), _buffer(buffer) { }
+    FileWriter(std::filesystem::path path, std::shared_ptr<Bytebuffer>& buffer) : _path(path), _buffer(buffer) { }
 
-	bool Write()
-	{
-		// Create a file
-		std::ofstream output(_path, std::ofstream::out | std::ofstream::binary);
-		if (!output)
-		{
-			DebugHandler::PrintError("[FileWriter] Failed to create file ({0}). Check admin permissions", _path.string().c_str());
-			return false;
-		}
+    bool Write()
+    {
+        // Create a file
+        std::ofstream output(_path, std::ofstream::out | std::ofstream::binary);
+        if (!output)
+        {
+            DebugHandler::PrintError("[FileWriter] Failed to create file ({0}). Check admin permissions", _path.string().c_str());
+            return false;
+        }
 
-		output.write(reinterpret_cast<char const*>(_buffer->GetDataPointer()), _buffer->writtenData);
+        output.write(reinterpret_cast<char const*>(_buffer->GetDataPointer()), _buffer->writtenData);
 
-		output.close();
-		return true;
-	}
+        output.close();
+        return true;
+    }
 
-	const std::filesystem::path& GetPath() { return _path; }
+    const std::filesystem::path& GetPath() { return _path; }
 
 private:
-	std::filesystem::path _path;
-	std::shared_ptr<Bytebuffer> _buffer;
+    std::filesystem::path _path;
+    std::shared_ptr<Bytebuffer> _buffer;
 };
\ No newline at end of file
diff --git a/Source/Base/Base/Util/DebugHandler.h b/Source/Base/Base/Util/DebugHandler.h
index 0d969f27..3ec5db63 100644
--- a/Source/Base/Base/Util/DebugHandler.h
+++ b/Source/Base/Base/Util/DebugHandler.h
@@ -6,67 +6,81 @@
 #include <spdlog/fmt/fmt.h>
 #include <spdlog/fmt/bundled/color.h>
 
+#include <format>
 #include <string>
+#include <source_location>
 
 PRAGMA_CLANG_DIAGNOSTIC_PUSH;
 PRAGMA_CLANG_DIAGNOSTIC_IGNORE(-Wformat-security);
 PRAGMA_CLANG_DIAGNOSTIC_IGNORE(-Wnon-pod-varargs);
 
+namespace Logging
+{
+    using source_location = std::source_location;
+    [[nodiscard]] constexpr auto get_log_source_location(const source_location& location)
+    {
+        return spdlog::source_loc { location.file_name(), static_cast<std::int32_t>(location.line()), location.function_name() };
+    }
+
+    struct format_with_location
+    {
+        std::string_view value;
+        spdlog::source_loc loc;
+
+        template <typename String>
+        format_with_location(const String& s, const source_location& location = source_location::current()) : value{ s }, loc{ get_log_source_location(location) } {}
+    };
+}
+
 class DebugHandler
 {
 public:
-	template <typename... Args>
-	inline static void Print(spdlog::level::level_enum level, const std::string& message, Args... args)
-	{
-		spdlog::log(level, message, std::forward<Args>(args)...);
-	}
-
-	template <typename... Args>
-	inline static void Print(const std::string& message, Args... args)
-	{
-		Print(spdlog::level::level_enum::info, message, std::forward<Args>(args)...);
-	}
+    template <typename... Args>
+    inline static void Print(const std::string_view fmt, Args... args)
+    {
+        spdlog::default_logger_raw()->log(spdlog::level::info, std::vformat(fmt, std::make_format_args(std::forward<Args>(args)...)));
+    }
 
-	template <typename... Args>
-	inline static void PrintTrace(const std::string& message, Args... args)
-	{
-		Print(spdlog::level::level_enum::trace, message, std::forward<Args>(args)...);
-	}
+    template <typename... Args>
+    inline static void PrintTrace(const Logging::format_with_location& fmt, Args... args)
+    {
+        spdlog::default_logger_raw()->log(fmt.loc, spdlog::level::trace, std::vformat(fmt.value, std::make_format_args(std::forward<Args>(args)...)));
+    }
 
-	template <typename... Args>
-	inline static void PrintDebug(const std::string& message, Args... args)
-	{
-		Print(spdlog::level::level_enum::debug, message, std::forward<Args>(args)...);
-	}
+    template <typename... Args>
+    inline static void PrintDebug(const Logging::format_with_location& fmt, Args... args)
+    {
+        spdlog::default_logger_raw()->log(fmt.loc, spdlog::level::debug, std::vformat(fmt.value, std::make_format_args(std::forward<Args>(args)...)));
+    }
 
-	template <typename... Args>
-	inline static void PrintWarning(const std::string& message, Args... args)
-	{
-		Print(spdlog::level::level_enum::warn, message, std::forward<Args>(args)...);
-	}
+    template <typename... Args>
+    inline static void PrintWarning(const Logging::format_with_location& fmt, Args... args)
+    {
+        spdlog::default_logger_raw()->log(fmt.loc, spdlog::level::warn, std::vformat(fmt.value, std::make_format_args(std::forward<Args>(args)...)));
+    }
 
-	template <typename... Args>
-	inline static void PrintError(const std::string& message, Args... args)
-	{
-		Print(spdlog::level::level_enum::err, message, std::forward<Args>(args)...);
-	}
+    template <typename... Args>
+    inline static void PrintError(const Logging::format_with_location& fmt, Args... args)
+    {
+        spdlog::default_logger_raw()->log(fmt.loc, spdlog::level::err, std::vformat(fmt.value, std::make_format_args(std::forward<Args>(args)...)));
+    }
 
-	template <typename... Args>
-	inline static void PrintFatal(const std::string& message, Args... args)
-	{
-		Print(spdlog::level::level_enum::critical, message, std::forward<Args>(args)...);
+    template <typename... Args>
+    inline static void PrintFatal(const Logging::format_with_location& fmt, Args... args)
+    {
+        spdlog::default_logger_raw()->log(fmt.loc, spdlog::level::critical, std::vformat(fmt.value, std::make_format_args(std::forward<Args>(args)...)));
 
-		ReleaseModeBreakpoint();
-	}
+        ReleaseModeBreakpoint();
+    }
 
-	template <typename... Args>
-	inline static void Assert(bool assertion, const std::string& message, Args... args)
-	{
-		if (!assertion)
-		{
-			PrintFatal(message, std::forward<Args>(args)...);
-		}
-	}
+    template <typename... Args>
+    inline static void Assert(bool assertion, const Logging::format_with_location& fmt, Args... args)
+    {
+        if (!assertion)
+        {
+            PrintFatal(fmt, std::forward<Args>(args)...);
+        }
+    }
 
 private:
 };
diff --git a/Source/Base/Base/Util/Reflection.h b/Source/Base/Base/Util/Reflection.h
index 74adb77f..8bdaf5b4 100644
--- a/Source/Base/Base/Util/Reflection.h
+++ b/Source/Base/Base/Util/Reflection.h
@@ -5,11 +5,11 @@
 
 namespace Reflection
 {
-	struct ReadOnly : refl::attr::usage::field {};
-	struct Hidden : refl::attr::usage::field, refl::attr::usage::function {};
-	struct DragSpeed : refl::attr::usage::field
-	{
-		constexpr DragSpeed(f32 speed) : speed(speed) {}
-		f32 speed;
-	};
+    struct ReadOnly : refl::attr::usage::field {};
+    struct Hidden : refl::attr::usage::field, refl::attr::usage::function {};
+    struct DragSpeed : refl::attr::usage::field
+    {
+        constexpr DragSpeed(f32 speed) : speed(speed) {}
+        f32 speed;
+    };
 }
\ No newline at end of file
diff --git a/Source/FileFormat/FileFormat/Novus/Model/ComplexModel.h b/Source/FileFormat/FileFormat/Novus/Model/ComplexModel.h
index 82939b02..18df54ff 100644
--- a/Source/FileFormat/FileFormat/Novus/Model/ComplexModel.h
+++ b/Source/FileFormat/FileFormat/Novus/Model/ComplexModel.h
@@ -59,7 +59,7 @@ namespace Model
 
         public:
             AnimationTrack() { }
-            AnimationTrack(AnimationTrack<T>& other) : sequenceID(sequenceID)
+            AnimationTrack(AnimationTrack<T>& other)
             {
                 size_t numTimestamps = other.timestamps.size();
                 if (numTimestamps)
@@ -86,7 +86,7 @@ namespace Model
                     }
                 }
             }
-            AnimationTrack(AnimationTrack<T>&& other) : timestamps(std::move(other.timestamps)), values(std::move(other.values)) { }
+            AnimationTrack(AnimationTrack<T>&& other) noexcept : timestamps(std::move(other.timestamps)), values(std::move(other.values)) { }
             AnimationTrack<T>& operator=(const AnimationTrack<T>& other)
             {
                 size_t numTimestamps = other.timestamps.size();
@@ -141,7 +141,7 @@ namespace Model
             AnimationData(AnimationData<T>& other)
             {
                 interpolationType = other.interpolationType;
-                isGlobalSequence = other.isGlobalSequence;
+                globalLoopIndex = other.globalLoopIndex;
 
                 size_t numTracks = other.tracks.size();
                 tracks.resize(numTracks);
@@ -151,7 +151,7 @@ namespace Model
                     tracks[i] = other.tracks[i];
                 }
             }
-            AnimationData(AnimationData<T>&& other) : interpolationType(other.interpolationType), globalLoopIndex(other.globalLoopIndex), tracks(std::move(other.tracks)) { }
+            AnimationData(AnimationData<T>&& other) noexcept : interpolationType(other.interpolationType), globalLoopIndex(other.globalLoopIndex), tracks(std::move(other.tracks)) { }
             AnimationData<T>& operator=(const AnimationData<T>& other)
             {
                 interpolationType = other.interpolationType;
diff --git a/Source/Renderer/Renderer/Renderers/Vulkan/Backend/RenderDeviceVK.cpp b/Source/Renderer/Renderer/Renderers/Vulkan/Backend/RenderDeviceVK.cpp
index bd7d0a62..76abdb80 100644
--- a/Source/Renderer/Renderer/Renderers/Vulkan/Backend/RenderDeviceVK.cpp
+++ b/Source/Renderer/Renderer/Renderers/Vulkan/Backend/RenderDeviceVK.cpp
@@ -1436,7 +1436,7 @@ namespace Renderer
                 }
                 else
                 {
-                    DebugHandler::PrintFatal("Tried to use a format that wasn't uncompressed or used BC compression, what is this? id: {}", format);
+                    DebugHandler::PrintFatal("Tried to use a format that wasn't uncompressed or used BC compression, what is this? id: {}", static_cast<std::underlying_type<VkFormat>::type>(format));
                 }
 
                 curWidth = Math::Max(1, curWidth / 2);
diff --git a/Source/Renderer/Renderer/Renderers/Vulkan/Backend/ShaderHandlerVK.h b/Source/Renderer/Renderer/Renderers/Vulkan/Backend/ShaderHandlerVK.h
index 433a5f44..b6c630aa 100644
--- a/Source/Renderer/Renderer/Renderers/Vulkan/Backend/ShaderHandlerVK.h
+++ b/Source/Renderer/Renderer/Renderers/Vulkan/Backend/ShaderHandlerVK.h
@@ -6,6 +6,7 @@
 
 #include <Base/Types.h>
 #include <Base/Util/DebugHandler.h>
+#include <Base/Util/StringUtils.h>
 
 #include <vulkan/vulkan_core.h>
 
diff --git a/Source/Renderer/Renderer/Renderers/Vulkan/RendererVK.cpp b/Source/Renderer/Renderer/Renderers/Vulkan/RendererVK.cpp
index ba6c7c70..a377d127 100644
--- a/Source/Renderer/Renderer/Renderers/Vulkan/RendererVK.cpp
+++ b/Source/Renderer/Renderer/Renderers/Vulkan/RendererVK.cpp
@@ -810,7 +810,7 @@ namespace Renderer
                 {
                     if (set != bindInfo.set)
                     {
-                        DebugHandler::PrintError("While creating DescriptorSet, we found BindInfo with matching name ({}) and type ({}), but it didn't match the location ({} != {})", bindInfo.name, bindInfo.descriptorType, bindInfo.set, set);
+                        DebugHandler::PrintError("While creating DescriptorSet, we found BindInfo with matching name ({}) and type ({}), but it didn't match the location ({} != {})", bindInfo.name, static_cast<std::underlying_type<DescriptorType>::type>(bindInfo.descriptorType), bindInfo.set, set);
                     }
                 }
                 else